| /*****************************************************************************\ |
| * job_info.c - Functions related to job display mode of sview. |
| ***************************************************************************** |
| * Copyright (C) SchedMD LLC. |
| * Copyright (C) 2008-2011 Lawrence Livermore National Security. |
| * Copyright (C) 2004-2007 The Regents of the University of California. |
| * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). |
| * Written by Danny Auble <da@llnl.gov> |
| * |
| * CODE-OCEC-09-009. All rights reserved. |
| * |
| * This file is part of Slurm, a resource management program. |
| * For details, see <https://slurm.schedmd.com/>. |
| * Please also read the included file: DISCLAIMER. |
| * |
| * Slurm is free software; you can redistribute it and/or modify it under |
| * the terms of the GNU General Public License as published by the Free |
| * Software Foundation; either version 2 of the License, or (at your option) |
| * any later version. |
| * |
| * Slurm is distributed in the hope that it will be useful, but WITHOUT ANY |
| * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more |
| * details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with Slurm; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| \*****************************************************************************/ |
| |
| #include <fcntl.h> |
| #include <grp.h> |
| #include <limits.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| |
| #include "src/common/parse_time.h" |
| #include "src/common/proc_args.h" |
| #include "src/interfaces/select.h" |
| #include "src/common/uid.h" |
| #include "src/common/xstring.h" |
| |
| #include "src/sview/sview.h" |
| |
| #define _DEBUG 0 |
| #define MAX_CANCEL_RETRY 10 |
| #define SIZE(a) (sizeof(a)/sizeof(a[0])) |
| |
| /* We do not read the node table here, but allocated space for up to |
| * MAX_NODE_SPACE nodes and generate fatal error if we go higher. Increase |
| * this value if needed */ |
| #ifndef SVIEW_MAX_NODE_SPACE |
| #define SVIEW_MAX_NODE_SPACE (24 * 1024) |
| #endif |
| |
| /* Collection of data for printing reports. Like data is combined here */ |
| typedef struct { |
| int color_inx; |
| GtkTreeIter iter_ptr; |
| bool iter_set; |
| uint32_t job_id; |
| char *job_id_str; |
| job_info_t *job_ptr; |
| int node_cnt; |
| char *nodes; |
| int pos; |
| list_t *step_list; |
| hostlist_t *task_hl; |
| char *task_hl_str; |
| hostlist_t *task_pending_hl; |
| char *task_pending_hl_str; |
| list_t *task_list; |
| list_t *task_pending_list; |
| } sview_job_info_t; |
| |
| static list_t *foreach_list = NULL; |
| static char *stacked_job_list = NULL; |
| |
| typedef struct { |
| int state; |
| slurm_step_id_t step_id; |
| int array_job_id; |
| int array_task_id; |
| int het_job_id; |
| int het_job_offset; |
| } jobs_foreach_t; |
| |
| typedef struct { |
| int edit_type; |
| GtkWidget *entry; |
| job_desc_msg_t *job_msg; |
| char *type; |
| } jobs_foreach_common_t; |
| |
| enum { |
| EDIT_SIGNAL = 1, |
| EDIT_SIGNAL_USER, |
| EDIT_CANCEL, |
| EDIT_CANCEL_USER, |
| EDIT_REQUEUE, |
| EDIT_SUSPEND, |
| EDIT_EDIT |
| }; |
| |
| /* These need to be in alpha order (except POS and CNT) */ |
| enum { |
| SORTID_POS = POS_LOC, |
| SORTID_ACCOUNT, |
| SORTID_ACTION, |
| SORTID_ALLOC, |
| SORTID_ALLOC_NODE, |
| SORTID_ARRAY_JOB_ID, |
| SORTID_ARRAY_TASK_ID, |
| SORTID_BATCH, |
| SORTID_BATCH_HOST, |
| SORTID_BURST_BUFFER, |
| SORTID_CLUSTER_NAME, |
| SORTID_COLOR, |
| SORTID_COLOR_INX, |
| SORTID_COMMAND, |
| SORTID_COMMENT, |
| SORTID_CONTIGUOUS, |
| SORTID_CORE_SPEC, |
| /* SORTID_CORES_MAX, */ |
| /* SORTID_CORES_MIN, */ |
| SORTID_CPUS, |
| SORTID_CPUS_PER_TRES, |
| SORTID_CPU_MAX, |
| SORTID_CPU_MIN, |
| SORTID_CPUS_PER_TASK, |
| SORTID_DEADLINE, |
| SORTID_DEPENDENCY, |
| SORTID_DERIVED_EC, |
| SORTID_EXIT_CODE, |
| SORTID_EXTRA, |
| SORTID_FEATURES, |
| SORTID_FED_ACTIVE_SIBS, |
| SORTID_FED_ORIGIN, |
| SORTID_FED_VIABLE_SIBS, |
| SORTID_GRES, |
| SORTID_GROUP_ID, |
| SORTID_HET_JOB_ID, |
| SORTID_HET_JOB_ID_SET, |
| SORTID_HET_JOB_OFFSET, |
| SORTID_JOBID, |
| SORTID_JOBID_FORMATTED, |
| SORTID_LAST_SCHED_EVAL, |
| SORTID_LICENSES, |
| SORTID_MCS_LABEL, |
| SORTID_CPU_REQ, |
| SORTID_MEM_MIN, |
| SORTID_MEM_PER_TRES, |
| SORTID_TMP_DISK, |
| SORTID_NAME, |
| SORTID_NETWORK, |
| SORTID_NICE, |
| SORTID_NODELIST, |
| SORTID_NODELIST_EXC, |
| SORTID_NODELIST_REQ, |
| SORTID_NODELIST_SCHED, |
| SORTID_NODE_INX, |
| SORTID_NODES, |
| SORTID_NODES_MAX, |
| SORTID_NODES_MIN, |
| /* SORTID_NTASKS_PER_CORE, */ |
| /* SORTID_NTASKS_PER_NODE, */ |
| /* SORTID_NTASKS_PER_SOCKET, */ |
| SORTID_OVER_SUBSCRIBE, |
| SORTID_PARTITION, |
| SORTID_PREEMPT_TIME, |
| SORTID_PREFER, |
| SORTID_PRIORITY, |
| SORTID_QOS, |
| SORTID_REASON, |
| SORTID_REBOOT, |
| SORTID_REQUEUE, |
| SORTID_RESV_NAME, |
| SORTID_RESTARTS, |
| /* SORTID_SOCKETS_MAX, */ |
| /* SORTID_SOCKETS_MIN, */ |
| SORTID_STATE, |
| SORTID_STATE_NUM, |
| SORTID_STD_ERR, |
| SORTID_STD_IN, |
| SORTID_STD_OUT, |
| SORTID_SWITCHES, |
| SORTID_TASKS, |
| SORTID_THREAD_SPEC, |
| /* SORTID_THREADS_MAX, */ |
| /* SORTID_THREADS_MIN, */ |
| SORTID_TIME_ACCRUE, |
| SORTID_TIME_ELIGIBLE, |
| SORTID_TIME_END, |
| SORTID_TIMELIMIT, |
| SORTID_TIME_RESIZE, |
| SORTID_TIME_RUNNING, |
| SORTID_TIME_START, |
| SORTID_TIME_SUBMIT, |
| SORTID_TIME_SUSPEND, |
| SORTID_TRES_ALLOC, |
| SORTID_TRES_BIND, |
| SORTID_TRES_FREQ, |
| SORTID_TRES_PER_JOB, |
| SORTID_TRES_PER_NODE, |
| SORTID_TRES_PER_SOCKET, |
| SORTID_TRES_PER_TASK, |
| SORTID_UPDATED, |
| SORTID_USER_ID, |
| SORTID_WCKEY, |
| SORTID_WORKDIR, |
| SORTID_CNT |
| }; |
| |
| /* extra field here is for choosing the type of edit that will |
| * take place. If you choose EDIT_MODEL (means only display a set of |
| * known options) create it in function create_model_*. |
| */ |
| static char *_initial_page_opts = ("JobID,Partition,UserID,Name," |
| "State,Time_Running,Node_Count,NodeList"); |
| |
| static display_data_t display_data_job[] = { |
| {G_TYPE_INT, SORTID_POS, NULL, false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_JOBID, "JobID", false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_JOBID_FORMATTED, NULL, false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_COLOR, NULL, true, EDIT_COLOR, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_ACTION, "Action", false, |
| EDIT_MODEL, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_INT, SORTID_ALLOC, NULL, false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_ARRAY_JOB_ID, "Array_Job_ID", false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_ARRAY_TASK_ID, "Array_Task_ID", false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_PARTITION, "Partition", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_HET_JOB_ID, "Hetjob JobID", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_HET_JOB_ID_SET, "Hetjob JobID Set", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_HET_JOB_OFFSET, "Hetjob Offset", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_USER_ID, "UserID", false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_GROUP_ID, "GroupID", false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_WCKEY, "WCKey", false, EDIT_TEXTBOX, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NAME, "Name", false, EDIT_TEXTBOX, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_STATE, "State", false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_INT, SORTID_STATE_NUM, NULL, false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_PREEMPT_TIME, "Preempt Time", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_RESIZE, "Time Resize", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_RUNNING, "Time Running", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_SUBMIT, "Time Submit", false, |
| EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_ACCRUE, "Time Accrue", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_ELIGIBLE, "Time Eligible", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_START, "Time Start", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_END, "Time End", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_DEADLINE, "Deadline", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIME_SUSPEND, "Time Suspended", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TIMELIMIT, "Time Limit", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODES, "Node Count", false, EDIT_TEXTBOX, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPUS, "CPU Count", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODELIST, "NodeList", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODELIST_EXC, "NodeList Excluded", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODELIST_REQ, "NodeList Requested", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODELIST_SCHED, "NodeList Scheduled", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CONTIGUOUS, "Contiguous", false, EDIT_MODEL, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CORE_SPEC, "CoreSpec", false, EDIT_TEXTBOX, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_THREAD_SPEC, "ThreadSpec", false, EDIT_TEXTBOX, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_REBOOT, "Reboot", false, EDIT_MODEL, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_REQUEUE, "Requeue", false, EDIT_MODEL, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_INT, SORTID_RESTARTS, "Restart Count", false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| /* Priority is a string so we can edit using a text box */ |
| {G_TYPE_STRING, SORTID_PRIORITY, "Priority", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_DERIVED_EC, "Derived Exit Code", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_EXIT_CODE, "Exit Code", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_BATCH, "Batch Flag", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_BATCH_HOST, "Batch Host", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_BURST_BUFFER, "Burst Buffer", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CLUSTER_NAME, "ClusterName", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPU_MIN, "CPUs Min", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPU_MAX, "CPUs Max", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TASKS, "Task Count", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_OVER_SUBSCRIBE, "OverSubscribe", false, |
| EDIT_MODEL, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_STD_ERR, "Standard Error", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_STD_IN, "Standard In", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_STD_OUT, "Standard Out", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPUS_PER_TASK, "CPUs per Task", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_RESV_NAME, "Reservation Name", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODES_MIN, "Nodes (minimum)", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NODES_MAX, "Nodes Max", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPU_REQ, "Min CPUs Per Node", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_MEM_MIN, "Min Memory", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TMP_DISK, "Min Tmp Disk Per Node", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| /* Nice is a string so we can edit using a text box */ |
| {G_TYPE_STRING, SORTID_NICE, "Nice", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_ACCOUNT, "Account", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_QOS, "QOS", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_REASON, "Reason Waiting", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_SWITCHES, "Switches", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_FEATURES, "Features", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_PREFER, "Prefer", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_FED_ACTIVE_SIBS, "FedActiveSiblings", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_FED_ORIGIN, "FedOrigin", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_FED_VIABLE_SIBS, "FedViableSiblings", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| /* "gres" replaced by "tres_per_node" in v18.08 */ |
| {G_TYPE_STRING, SORTID_GRES, "Gres", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_LAST_SCHED_EVAL, "Last Sched Eval", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_LICENSES, "Licenses", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_MCS_LABEL, "MCS_Label", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_DEPENDENCY, "Dependency", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_ALLOC_NODE, "Alloc Node : Sid", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_NETWORK, "Network", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_COMMAND, "Command", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_COMMENT, "Comment", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_EXTRA, "Extra", |
| false, EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_WORKDIR, "Work Dir", |
| false, EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_INT, SORTID_COLOR_INX, NULL, false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_POINTER, SORTID_NODE_INX, NULL, false, EDIT_NONE, |
| refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_CPUS_PER_TRES, "CPUs per TRES", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_MEM_PER_TRES, "Mem per TRES", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_ALLOC, "TRES Alloc", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_BIND, "TRES Bind", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_FREQ, "TRES Freq", false, |
| EDIT_NONE, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_PER_JOB, "TRES Per Job", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_PER_NODE, "TRES Per Node", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_PER_SOCKET, "TRES Per Socket", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_STRING, SORTID_TRES_PER_TASK, "TRES Per Task", false, |
| EDIT_TEXTBOX, refresh_job, create_model_job, admin_edit_job}, |
| {G_TYPE_INT, SORTID_UPDATED, NULL, false, EDIT_NONE, refresh_job, |
| create_model_job, admin_edit_job}, |
| {G_TYPE_NONE, -1, NULL, false, EDIT_NONE} |
| }; |
| |
| static display_data_t options_data_job[] = { |
| {G_TYPE_INT, SORTID_POS, NULL, false, EDIT_NONE}, |
| {G_TYPE_STRING, INFO_PAGE, "Full Info", true, JOB_PAGE}, |
| {G_TYPE_STRING, JOB_PAGE, "Signal", true, ADMIN_PAGE}, |
| {G_TYPE_STRING, JOB_PAGE, "Requeue", true, ADMIN_PAGE}, |
| {G_TYPE_STRING, JOB_PAGE, "Cancel", true, ADMIN_PAGE}, |
| {G_TYPE_STRING, JOB_PAGE, "Suspend/Resume", true, ADMIN_PAGE}, |
| {G_TYPE_STRING, JOB_PAGE, "Edit Job", true, ADMIN_PAGE}, |
| {G_TYPE_STRING, PART_PAGE, "Partition", true, JOB_PAGE}, |
| {G_TYPE_STRING, NODE_PAGE, "Nodes", true, JOB_PAGE}, |
| {G_TYPE_STRING, RESV_PAGE, "Reservation", true, JOB_PAGE}, |
| {G_TYPE_NONE, -1, NULL, false, EDIT_NONE} |
| }; |
| |
| struct signv { |
| char *name; |
| uint16_t val; |
| } sig_name_num[ ] = { |
| { "HUP", SIGHUP }, |
| { "INT", SIGINT }, |
| { "QUIT", SIGQUIT }, |
| { "ABRT", SIGABRT }, |
| { "KILL", SIGKILL }, |
| { "ALRM", SIGALRM }, |
| { "TERM", SIGTERM }, |
| { "USR1", SIGUSR1 }, |
| { "USR2", SIGUSR2 }, |
| { "CONT", SIGCONT }, |
| { "STOP", SIGSTOP }, |
| { "TSTP", SIGTSTP }, |
| { "TTIN", SIGTTIN }, |
| { "TTOU", SIGTTOU }, |
| { "XCPU", SIGXCPU }, |
| { "SIGHUP", SIGHUP }, |
| { "SIGINT", SIGINT }, |
| { "SIGQUIT", SIGQUIT }, |
| { "SIGABRT", SIGABRT }, |
| { "SIGKILL", SIGKILL }, |
| { "SIGALRM", SIGALRM }, |
| { "SIGTERM", SIGTERM }, |
| { "SIGUSR1", SIGUSR1 }, |
| { "SIGUSR2", SIGUSR2 }, |
| { "SIGCONT", SIGCONT }, |
| { "SIGSTOP", SIGSTOP }, |
| { "SIGTSTP", SIGTSTP }, |
| { "SIGTTIN", SIGTTIN }, |
| { "SIGTTOU", SIGTTOU }, |
| { "SIGXCPU", SIGXCPU }, |
| }; |
| |
| static display_data_t *local_display_data = NULL; |
| static char *got_edit_signal = NULL; |
| static GtkTreeModel *last_model = NULL; |
| |
| static void _update_info_task(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeModel *model, |
| GtkTreeIter *task_iter, |
| GtkTreeIter *iter, bool handle_pending); |
| |
| static void _update_info_step(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeModel *model, |
| GtkTreeIter *step_iter, |
| GtkTreeIter *iter); |
| |
| static char *_read_file(const char *f_name) |
| { |
| int fd, f_size, offset = 0; |
| ssize_t rd_size; |
| struct stat f_stat; |
| char *buf; |
| |
| fd = open(f_name, 0); |
| if (fd < 0) |
| return NULL; |
| if (fstat(fd, &f_stat)) { |
| close(fd); |
| return NULL; |
| } |
| f_size = f_stat.st_size; |
| buf = xmalloc(f_size + 1); |
| while (offset < f_size) { |
| rd_size = read(fd, buf+offset, f_size-offset); |
| if (rd_size < 0) { |
| if ((errno == EAGAIN) || (errno == EINTR)) |
| continue; |
| xfree(buf); |
| break; |
| } |
| offset += rd_size; |
| } |
| close(fd); |
| buf[f_size] = '\0'; |
| return buf; |
| } |
| |
| static void _job_info_free(sview_job_info_t *sview_job_info) |
| { |
| if (sview_job_info) { |
| xfree(sview_job_info->job_id_str); |
| xfree(sview_job_info->nodes); |
| |
| FREE_NULL_LIST(sview_job_info->step_list); |
| FREE_NULL_LIST(sview_job_info->task_list); |
| FREE_NULL_LIST(sview_job_info->task_pending_list); |
| |
| xfree(sview_job_info->task_hl_str); |
| xfree(sview_job_info->task_pending_hl_str); |
| |
| FREE_NULL_HOSTLIST(sview_job_info->task_hl); |
| FREE_NULL_HOSTLIST(sview_job_info->task_pending_hl); |
| } |
| } |
| |
| static void _job_info_list_del(void *object) |
| { |
| sview_job_info_t *sview_job_info = (sview_job_info_t *)object; |
| |
| if (sview_job_info) { |
| _job_info_free(sview_job_info); |
| xfree(sview_job_info); |
| } |
| } |
| |
| /* translate signal name to number */ |
| static uint16_t _xlate_signal_name(const char *signal_name) |
| { |
| uint16_t sig_num = NO_VAL16; |
| char *end_ptr, *sig_names = NULL; |
| int i; |
| |
| sig_num = (uint16_t) strtol(signal_name, &end_ptr, 10); |
| |
| if ((*end_ptr == '\0') && (sig_num != 0)) |
| return sig_num; |
| |
| for (i=0; i<SIZE(sig_name_num); i++) { |
| if (xstrcasecmp(sig_name_num[i].name, signal_name) == 0) { |
| xfree(sig_names); |
| return sig_name_num[i].val; |
| } |
| if (i == 0) |
| sig_names = xstrdup(sig_name_num[i].name); |
| else { |
| xstrcat(sig_names, ","); |
| xstrcat(sig_names, sig_name_num[i].name); |
| } |
| } |
| xfree(sig_names); |
| return NO_VAL16; |
| } |
| |
| static int _cancel_job_id (uint32_t job_id, uint16_t signal) |
| { |
| int error_code = SLURM_SUCCESS, i; |
| char *temp = NULL; |
| |
| if (signal == (uint16_t)-1) |
| signal = SIGKILL; |
| for (i = 0; i < MAX_CANCEL_RETRY; i++) { |
| /* NOTE: RPC always sent to slurmctld rather than directly |
| * to slurmd daemons */ |
| error_code = slurm_kill_job(job_id, signal, false); |
| if (error_code == 0 |
| || (errno != ESLURM_TRANSITION_STATE_NO_UPDATE |
| && errno != ESLURM_JOB_PENDING)) |
| break; |
| temp = g_strdup_printf("Sending signal %u to job %u", |
| signal, job_id); |
| display_edit_note(temp); |
| g_free(temp); |
| sleep ( 5 + i ); |
| } |
| if (error_code) { |
| error_code = errno; |
| if ((error_code != ESLURM_ALREADY_DONE) && |
| (error_code != ESLURM_INVALID_JOB_ID)) { |
| temp = g_strdup_printf( |
| "Kill job error on job id %u: %s", |
| job_id, slurm_strerror(errno)); |
| display_edit_note(temp); |
| g_free(temp); |
| } else { |
| display_edit_note(slurm_strerror(errno)); |
| } |
| } |
| |
| return error_code; |
| } |
| |
| static int _cancel_step_id(uint32_t job_id, uint32_t step_id, |
| uint16_t signal) |
| { |
| int error_code = SLURM_SUCCESS, i; |
| char *temp = NULL; |
| char tmp_char[45]; |
| slurm_step_id_t step_id_tmp = { |
| .job_id = job_id, |
| .step_het_comp = NO_VAL, |
| .step_id = step_id, |
| }; |
| |
| log_build_step_id_str(&step_id_tmp, tmp_char, sizeof(tmp_char), |
| STEP_ID_FLAG_NONE); |
| |
| if (signal == (uint16_t)-1) |
| signal = SIGKILL; |
| |
| for (i = 0; i < MAX_CANCEL_RETRY; i++) { |
| /* NOTE: RPC always sent to slurmctld rather than directly |
| * to slurmd daemons */ |
| error_code = slurm_kill_job_step(job_id, step_id, signal, 0); |
| |
| if (error_code == 0 |
| || (errno != ESLURM_TRANSITION_STATE_NO_UPDATE |
| && errno != ESLURM_JOB_PENDING)) |
| break; |
| temp = g_strdup_printf("Sending signal %u to %s", |
| signal, tmp_char); |
| display_edit_note(temp); |
| g_free(temp); |
| sleep ( 5 + i ); |
| } |
| |
| if (error_code) { |
| error_code = errno; |
| if (error_code != ESLURM_ALREADY_DONE) { |
| temp = g_strdup_printf( |
| "Kill job error on %s: %s", |
| tmp_char, slurm_strerror(errno)); |
| display_edit_note(temp); |
| g_free(temp); |
| } else { |
| display_edit_note(slurm_strerror(errno)); |
| } |
| } |
| |
| return error_code; |
| } |
| |
| static void _set_active_combo_job(GtkComboBox *combo, |
| GtkTreeModel *model, GtkTreeIter *iter, |
| int type) |
| { |
| char *temp_char = NULL; |
| int action = 0; |
| |
| if (model) |
| gtk_tree_model_get(model, iter, type, &temp_char, -1); |
| if (!temp_char) |
| goto end_it; |
| switch(type) { |
| case SORTID_ACTION: |
| if (!xstrcasecmp(temp_char, "None")) |
| action = 0; |
| else if (!xstrcasecmp(temp_char, "Cancel")) |
| action = 1; |
| else if (!xstrcasecmp(temp_char, "Suspend")) |
| action = 2; |
| else if (!xstrcasecmp(temp_char, "Resume")) |
| action = 3; |
| else if (!xstrcasecmp(temp_char, "Requeue")) |
| action = 5; |
| else |
| action = 0; |
| |
| break; |
| case SORTID_CONTIGUOUS: |
| case SORTID_REBOOT: |
| case SORTID_REQUEUE: |
| case SORTID_OVER_SUBSCRIBE: |
| if (!xstrcasecmp(temp_char, "yes")) |
| action = 0; |
| else if (!xstrcasecmp(temp_char, "no")) |
| action = 1; |
| else |
| action = 0; |
| break; |
| default: |
| break; |
| } |
| g_free(temp_char); |
| end_it: |
| gtk_combo_box_set_active(combo, action); |
| |
| } |
| |
| |
| /* don't free this char */ |
| static const char *_set_job_msg(job_desc_msg_t *job_msg, const char *new_text, |
| int column) |
| { |
| char *type = ""; |
| int temp_int = 0; |
| long long int temp_ll = 0; |
| char *p; |
| char *token; |
| char *sep_char; |
| int j; |
| |
| /* need to clear global_edit_error here (just in case) */ |
| global_edit_error = 0; |
| if (!job_msg) |
| return NULL; |
| |
| switch (column) { |
| case SORTID_ACTION: |
| xfree(got_edit_signal); |
| if (!xstrcasecmp(new_text, "None")) |
| got_edit_signal = NULL; |
| else |
| got_edit_signal = xstrdup(new_text); |
| break; |
| case SORTID_COMMENT: |
| job_msg->comment = xstrdup(new_text); |
| type = "comment"; |
| break; |
| case SORTID_TIMELIMIT: |
| if (!xstrcasecmp(new_text, "infinite")) |
| temp_int = INFINITE; |
| else |
| temp_int = time_str2mins((char *)new_text); |
| |
| type = "timelimit"; |
| if (temp_int <= 0 && temp_int != INFINITE) |
| goto return_error; |
| job_msg->time_limit = (uint32_t)temp_int; |
| break; |
| case SORTID_PRIORITY: |
| if (!xstrcasecmp(new_text, "infinite")) |
| temp_int = INFINITE; |
| else |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| |
| type = "priority"; |
| if ((temp_int < 0) && (temp_int != INFINITE)) |
| goto return_error; |
| job_msg->priority = (uint32_t)temp_int; |
| break; |
| case SORTID_NICE: |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| type = "nice"; |
| if (abs(temp_int) > (int) NICE_OFFSET) { |
| //error("Invalid nice value, must be between " |
| // "-%d and %d", NICE_OFFSET, NICE_OFFSET); |
| goto return_error; |
| } |
| job_msg->nice = NICE_OFFSET + temp_int; |
| break; |
| case SORTID_CPU_REQ: |
| temp_int = strtol(new_text, &p, 10); |
| if (*p == 'k' || *p == 'K') |
| temp_int *= 1024; |
| else if (*p == 'm' || *p == 'M') |
| temp_int *= 1048576; |
| |
| type = "min cpus per node"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->pn_min_cpus = (uint32_t)temp_int; |
| break; |
| case SORTID_TASKS: |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| |
| type = "requested tasks"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->num_tasks = (uint32_t)temp_int; |
| break; |
| case SORTID_CPUS_PER_TASK: |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| |
| type = "cpus per task"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->cpus_per_task = (uint32_t)temp_int; |
| break; |
| case SORTID_RESV_NAME: |
| job_msg->reservation = xstrdup(new_text); |
| type = "reservation name"; |
| break; |
| case SORTID_NODES_MIN: |
| temp_int = strtol(new_text, &p, 10); |
| if (*p == 'k' || *p == 'K') |
| temp_int *= 1024; |
| else if (*p == 'm' || *p == 'M') |
| temp_int *= 1048576; |
| |
| type = "min nodes"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->min_nodes = (uint32_t)temp_int; |
| break; |
| case SORTID_NODES: |
| temp_int = strtol(new_text, &p, 10); |
| if (*p == 'k' || *p == 'K') |
| temp_int *= 1024; |
| else if (*p == 'm' || *p == 'M') |
| temp_int *= 1048576; |
| |
| type = "node count"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->min_nodes = job_msg->max_nodes = (uint32_t)temp_int; |
| break; |
| case SORTID_NODES_MAX: |
| temp_int = strtol(new_text, &p, 10); |
| if (*p == 'k' || *p == 'K') |
| temp_int *= 1024; |
| else if (*p == 'm' || *p == 'M') |
| temp_int *= 1048576; |
| |
| type = "max nodes"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->max_nodes = (uint32_t)temp_int; |
| break; |
| case SORTID_MEM_MIN: |
| temp_ll = strtoll(new_text, &p, 10); |
| if (*p == 'g' || *p == 'G') |
| temp_ll *= 1024; |
| else if (*p == 't' || *p == 'T') |
| temp_ll *= 1048576; |
| |
| p = xstrcasestr((char *)new_text, "tres"); |
| if (p) |
| goto return_error; |
| |
| p = xstrcasestr((char *)new_text, "cpu"); |
| if (p) |
| type = "min memory per cpu"; |
| else |
| type = "min memory per node"; |
| |
| if (temp_ll <= 0) |
| goto return_error; |
| job_msg->pn_min_memory = (uint64_t) temp_ll; |
| if (p) |
| job_msg->pn_min_memory |= MEM_PER_CPU; |
| break; |
| case SORTID_TMP_DISK: |
| temp_int = strtol(new_text, &p, 10); |
| if (*p == 'g' || *p == 'G') |
| temp_int *= 1024; |
| else if (*p == 't' || *p == 'T') |
| temp_int *= 1048576; |
| |
| type = "min tmp disk per node"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->pn_min_tmp_disk = (uint32_t)temp_int; |
| break; |
| case SORTID_PARTITION: |
| job_msg->partition = xstrdup(new_text); |
| type = "partition"; |
| break; |
| case SORTID_NAME: |
| job_msg->name = xstrdup(new_text); |
| type = "name"; |
| break; |
| case SORTID_HET_JOB_ID: |
| job_msg->name = xstrdup(new_text); |
| type = "hetjob jobid"; |
| break; |
| case SORTID_HET_JOB_ID_SET: |
| job_msg->name = xstrdup(new_text); |
| type = "hetjob id set"; |
| break; |
| case SORTID_HET_JOB_OFFSET: |
| job_msg->name = xstrdup(new_text); |
| type = "hetjob offset"; |
| break; |
| case SORTID_WCKEY: |
| job_msg->wckey = xstrdup(new_text); |
| type = "wckey"; |
| break; |
| case SORTID_OVER_SUBSCRIBE: |
| if (!xstrcasecmp(new_text, "yes")) |
| job_msg->shared = 1; |
| else |
| job_msg->shared = 0; |
| |
| type = "oversubscribe"; |
| break; |
| case SORTID_CONTIGUOUS: |
| if (!xstrcasecmp(new_text, "yes")) |
| job_msg->contiguous = 1; |
| else |
| job_msg->contiguous = 0; |
| |
| type = "contiguous"; |
| break; |
| case SORTID_CORE_SPEC: |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| |
| type = "specialized cores"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->core_spec = (uint16_t)temp_int; |
| break; |
| case SORTID_THREAD_SPEC: |
| temp_int = strtol(new_text, (char **)NULL, 10); |
| |
| type = "specialized threads"; |
| if (temp_int <= 0) |
| goto return_error; |
| job_msg->core_spec = (uint16_t)temp_int | CORE_SPEC_THREAD; |
| break; |
| case SORTID_REBOOT: |
| if (!xstrcasecmp(new_text, "yes")) |
| job_msg->reboot = 1; |
| else |
| job_msg->reboot = 0; |
| type = "reboot"; |
| break; |
| case SORTID_REQUEUE: |
| if (!xstrcasecmp(new_text, "yes")) |
| job_msg->requeue = 1; |
| else |
| job_msg->requeue = 0; |
| type = "requeue"; |
| break; |
| case SORTID_NODELIST_REQ: |
| job_msg->req_nodes = xstrdup(new_text); |
| type = "requested nodelist"; |
| break; |
| case SORTID_NODELIST_EXC: |
| job_msg->exc_nodes = xstrdup(new_text); |
| type = "excluded nodelist"; |
| break; |
| case SORTID_FEATURES: |
| job_msg->features = xstrdup(new_text); |
| type = "features"; |
| break; |
| case SORTID_PREFER: |
| job_msg->prefer = xstrdup(new_text); |
| type = "prefer"; |
| break; |
| case SORTID_CPUS_PER_TRES: |
| job_msg->cpus_per_tres = xstrdup(new_text); |
| type = "cpus_per_tres"; |
| break; |
| case SORTID_MEM_PER_TRES: |
| job_msg->mem_per_tres = xstrdup(new_text); |
| type = "mem_per_tres"; |
| break; |
| case SORTID_TRES_PER_JOB: |
| job_msg->tres_per_job = xstrdup(new_text); |
| type = "tres_per_job"; |
| break; |
| case SORTID_TRES_PER_NODE: |
| job_msg->tres_per_node = xstrdup(new_text); |
| type = "tres_per_node"; |
| break; |
| case SORTID_TRES_PER_SOCKET: |
| job_msg->tres_per_socket = xstrdup(new_text); |
| type = "tres_per_socket"; |
| break; |
| case SORTID_TRES_PER_TASK: |
| job_msg->tres_per_task = xstrdup(new_text); |
| type = "tres_per_task"; |
| break; |
| case SORTID_LICENSES: |
| job_msg->licenses = xstrdup(new_text); |
| type = "licenses"; |
| break; |
| case SORTID_MCS_LABEL: |
| job_msg->mcs_label = xstrdup(new_text); |
| type = "mcs_label"; |
| break; |
| case SORTID_ACCOUNT: |
| job_msg->account = xstrdup(new_text); |
| type = "account"; |
| break; |
| case SORTID_BURST_BUFFER: |
| job_msg->burst_buffer = xstrdup(new_text); |
| type = "burst buffer"; |
| break; |
| case SORTID_QOS: |
| job_msg->qos = xstrdup(new_text); |
| type = "qos"; |
| break; |
| case SORTID_COMMAND: |
| type = "script_file"; |
| xfree(job_msg->script); |
| job_msg->script = _read_file(new_text); |
| if (job_msg->script == NULL) |
| goto return_error; |
| if (job_msg->argc) { |
| for (j = 0; j < job_msg->argc; j++) |
| xfree(job_msg->argv[j]); |
| } |
| xfree(job_msg->argv); |
| xfree(job_msg->name); |
| job_msg->argc = 1; |
| job_msg->argv = xmalloc(sizeof(char *) * job_msg->argc); |
| if (new_text[0] == '/') { |
| job_msg->argv[0] = xstrdup(new_text); |
| token = strrchr(new_text, (int) '/'); |
| if (token) |
| job_msg->name = xstrdup(token + 1); |
| } else { |
| job_msg->argv[0] = xmalloc(PATH_MAX); |
| if (!getcwd(job_msg->argv[0], PATH_MAX)) |
| goto return_error; |
| xstrcat(job_msg->argv[0], "/"); |
| xstrcat(job_msg->argv[0], new_text); |
| job_msg->name = xstrdup(new_text); |
| } |
| break; |
| case SORTID_DEPENDENCY: |
| job_msg->dependency = xstrdup(new_text); |
| type = "dependency"; |
| break; |
| case SORTID_TIME_ELIGIBLE: |
| case SORTID_TIME_START: |
| type = "start time"; |
| job_msg->begin_time = parse_time((char *)new_text, 0); |
| if (!job_msg->begin_time) |
| goto return_error; |
| |
| if (job_msg->begin_time < time(NULL)) |
| job_msg->begin_time = time(NULL); |
| break; |
| case SORTID_DEADLINE: |
| type = "deadline"; |
| job_msg->deadline = parse_time((char *)new_text, 0); |
| if (!job_msg->deadline) |
| goto return_error; |
| if (job_msg->deadline < time(NULL)) |
| goto return_error; |
| break; |
| case SORTID_EXTRA: |
| job_msg->extra = xstrdup(new_text); |
| type = "extra"; |
| break; |
| case SORTID_STD_OUT: |
| type = "StdOut"; |
| job_msg->std_out = xstrdup(new_text); |
| break; |
| case SORTID_SWITCHES: |
| type = "switches"; |
| job_msg->req_switch = |
| (uint32_t) strtol(new_text, &sep_char, 10); |
| if (sep_char && sep_char[0] == '@') { |
| job_msg->wait4switch = time_str2mins(sep_char+1) * 60; |
| } |
| break; |
| default: |
| type = "unknown"; |
| break; |
| } |
| |
| if (xstrcmp(type, "unknown")) |
| global_send_update_msg = 1; |
| |
| return type; |
| |
| return_error: |
| global_edit_error = 1; |
| return type; |
| } |
| |
| static void _admin_edit_combo_box_job(GtkComboBox *combo, |
| job_desc_msg_t *job_msg) |
| { |
| GtkTreeModel *model = NULL; |
| GtkTreeIter iter; |
| int column = 0; |
| char *name = NULL; |
| |
| if (!job_msg) |
| return; |
| |
| if (!gtk_combo_box_get_active_iter(combo, &iter)) { |
| g_print("nothing selected\n"); |
| return; |
| } |
| model = gtk_combo_box_get_model(combo); |
| if (!model) { |
| g_print("nothing selected\n"); |
| return; |
| } |
| |
| gtk_tree_model_get(model, &iter, 0, &name, -1); |
| gtk_tree_model_get(model, &iter, 1, &column, -1); |
| |
| _set_job_msg(job_msg, name, column); |
| |
| g_free(name); |
| } |
| |
| static gboolean _admin_focus_out_job(GtkEntry *entry, |
| GdkEventFocus *event, |
| job_desc_msg_t *job_msg) |
| { |
| if (global_entry_changed) { |
| const char *col_name = NULL; |
| int type = gtk_entry_get_max_length(entry); |
| const char *name = gtk_entry_get_text(entry); |
| type -= DEFAULT_ENTRY_LENGTH; |
| |
| col_name = _set_job_msg(job_msg, name, type); |
| if (global_edit_error) { |
| if (global_edit_error_msg) |
| g_free(global_edit_error_msg); |
| global_edit_error_msg = g_strdup_printf( |
| "Job %d %s can't be set to %s", |
| job_msg->job_id, |
| col_name, |
| name); |
| } |
| global_entry_changed = 0; |
| } |
| return false; |
| } |
| |
| static GtkWidget *_admin_full_edit_job(job_desc_msg_t *job_msg, |
| GtkTreeModel *model, GtkTreeIter *iter) |
| { |
| GtkScrolledWindow *window = create_scrolled_window(); |
| GtkBin *bin = NULL; |
| GtkViewport *view = NULL; |
| GtkTable *table = NULL; |
| int i = 0, row = 0; |
| display_data_t *display_data = display_data_job; |
| |
| gtk_scrolled_window_set_policy(window, |
| GTK_POLICY_NEVER, |
| GTK_POLICY_AUTOMATIC); |
| bin = GTK_BIN(&window->container); |
| view = GTK_VIEWPORT(bin->child); |
| bin = GTK_BIN(&view->bin); |
| table = GTK_TABLE(bin->child); |
| gtk_table_resize(table, SORTID_CNT, 2); |
| |
| gtk_table_set_homogeneous(table, false); |
| |
| for(i = 0; i < SORTID_CNT; i++) { |
| while (display_data++) { |
| if (display_data->id == -1) |
| break; |
| if (!display_data->name) |
| continue; |
| if (display_data->id != i) |
| continue; |
| display_admin_edit( |
| table, job_msg, &row, model, iter, |
| display_data, |
| G_CALLBACK(_admin_edit_combo_box_job), |
| G_CALLBACK(_admin_focus_out_job), |
| _set_active_combo_job); |
| break; |
| } |
| display_data = display_data_job; |
| } |
| gtk_table_resize(table, row, 2); |
| |
| return GTK_WIDGET(window); |
| } |
| |
| static int _nodes_in_list(char *node_list) |
| { |
| hostset_t *host_set = hostset_create(node_list); |
| int count = hostset_count(host_set); |
| hostset_destroy(host_set); |
| return count; |
| } |
| |
| /* this needs to be freed by xfree() */ |
| static void _convert_char_to_job_and_step(const char *data, |
| int *jobid, int *stepid) |
| { |
| int i = 0; |
| |
| if (!data) |
| return; |
| *jobid = atoi(data); |
| *stepid = NO_VAL; |
| while (data[i]) { |
| if (data[i] == '.') { |
| i++; |
| if (data[i]) |
| *stepid = atoi(&data[i]); |
| break; |
| } |
| i++; |
| } |
| |
| return; |
| } |
| |
| static void _layout_job_record(GtkTreeView *treeview, |
| sview_job_info_t *sview_job_info_ptr, |
| int update) |
| { |
| char *nodes = NULL, *uname = NULL; |
| const char *reason = NULL; |
| char *group; |
| char tmp_char[256]; |
| char time_buf[32]; |
| char tmp1[128]; |
| char running_char[50]; |
| time_t now_time = time(NULL); |
| int suspend_secs = 0; |
| job_info_t *job_ptr = sview_job_info_ptr->job_ptr; |
| uint16_t term_code = 0, term_sig = 0; |
| uint64_t min_mem = 0; |
| |
| GtkTreeIter iter; |
| GtkTreeStore *treestore = |
| GTK_TREE_STORE(gtk_tree_view_get_model(treeview)); |
| |
| if (!treestore) |
| return; |
| |
| if (!job_ptr->nodes || IS_JOB_PENDING(job_ptr) || |
| !xstrcasecmp(job_ptr->nodes,"waiting...")) { |
| sprintf(running_char,"00:00:00"); |
| nodes = xstrdup("waiting..."); |
| } else { |
| if (IS_JOB_SUSPENDED(job_ptr)) |
| now_time = job_ptr->pre_sus_time; |
| else { |
| if (!IS_JOB_RUNNING(job_ptr) && |
| (job_ptr->end_time != 0)) |
| now_time = job_ptr->end_time; |
| if (job_ptr->suspend_time) { |
| now_time = (time_t) |
| (difftime(now_time, |
| job_ptr->suspend_time) |
| + job_ptr->pre_sus_time); |
| } else |
| now_time = (time_t)difftime( |
| now_time, job_ptr->start_time); |
| } |
| suspend_secs = (time(NULL) - job_ptr->start_time) - now_time; |
| secs2time_str(now_time, running_char, sizeof(running_char)); |
| |
| nodes = slurm_sort_node_list_str(sview_job_info_ptr->nodes); |
| } |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_ACCOUNT), |
| job_ptr->account); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%s:%u", |
| job_ptr->alloc_node, job_ptr->alloc_sid); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_ALLOC_NODE), |
| tmp_char); |
| |
| if (job_ptr->array_task_str || |
| (job_ptr->array_task_id != NO_VAL)) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| job_ptr->array_job_id); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "N/A"); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_ARRAY_JOB_ID), |
| tmp_char); |
| |
| if (job_ptr->array_task_str) { |
| snprintf(tmp_char, sizeof(tmp_char), "[%s]", |
| job_ptr->array_task_str); |
| } else if (job_ptr->array_task_id != NO_VAL) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| job_ptr->array_task_id); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "N/A"); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_ARRAY_TASK_ID), |
| tmp_char); |
| |
| if (job_ptr->batch_flag) |
| sprintf(tmp_char, "yes"); |
| else |
| sprintf(tmp_char, "no"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_BATCH), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_BATCH_HOST), |
| job_ptr->batch_host); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_BURST_BUFFER), |
| job_ptr->burst_buffer); |
| |
| if (job_ptr->cluster) { |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CLUSTER_NAME), |
| job_ptr->cluster); |
| } |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_COMMAND), |
| job_ptr->command); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_COMMENT), |
| job_ptr->comment); |
| |
| if (job_ptr->contiguous) |
| sprintf(tmp_char, "yes"); |
| else |
| sprintf(tmp_char, "no"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CONTIGUOUS), |
| tmp_char); |
| |
| if ((job_ptr->core_spec == NO_VAL16) || |
| (job_ptr->core_spec & CORE_SPEC_THREAD)) { |
| sprintf(tmp_char, "N/A"); |
| } else { |
| sprintf(tmp_char, "%u", job_ptr->core_spec); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CORE_SPEC), |
| tmp_char); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->num_cpus); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPUS), |
| tmp_char); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->max_cpus); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPU_MAX), |
| tmp_char); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->num_cpus); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPU_MIN), |
| tmp_char); |
| |
| if (job_ptr->cpus_per_task == NO_VAL16) |
| sprintf(tmp_char, "N/A"); |
| else |
| sprintf(tmp_char, "%u", job_ptr->cpus_per_task); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPUS_PER_TASK), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPUS_PER_TRES), |
| job_ptr->cpus_per_tres); |
| |
| if (job_ptr->deadline) |
| slurm_make_time_str((time_t *)&job_ptr->deadline, tmp_char, |
| sizeof(tmp_char)); |
| else |
| sprintf(tmp_char, "N/A"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_DEADLINE), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_DEPENDENCY), |
| job_ptr->dependency); |
| |
| if (WIFEXITED(job_ptr->derived_ec)) |
| term_code = WEXITSTATUS(job_ptr->derived_ec); |
| else |
| term_code = 0; |
| if (WIFSIGNALED(job_ptr->derived_ec)) |
| term_sig = WTERMSIG(job_ptr->derived_ec); |
| else |
| term_sig = 0; |
| snprintf(tmp_char, sizeof(tmp_char), "%u:%u", term_code, term_sig); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_DERIVED_EC), |
| tmp_char); |
| |
| if (WIFEXITED(job_ptr->exit_code)) |
| term_code = WEXITSTATUS(job_ptr->exit_code); |
| else |
| term_code = 0; |
| if (WIFSIGNALED(job_ptr->exit_code)) |
| term_sig = WTERMSIG(job_ptr->exit_code); |
| else |
| term_sig = 0; |
| snprintf(tmp_char, sizeof(tmp_char), "%u:%u", term_code, term_sig); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_EXIT_CODE), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_EXTRA), |
| job_ptr->extra); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_FEATURES), |
| job_ptr->features); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_PREFER), |
| job_ptr->prefer); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_FED_ACTIVE_SIBS), |
| job_ptr->fed_siblings_active_str); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_FED_ORIGIN), |
| job_ptr->fed_origin_str); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_FED_VIABLE_SIBS), |
| job_ptr->fed_siblings_viable_str); |
| |
| /* "gres" replaced by "tres_per_node" in v18.08 */ |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_GRES), |
| job_ptr->tres_per_node); |
| |
| group = gid_to_string(job_ptr->group_id); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_GROUP_ID), |
| group); |
| xfree(group); |
| |
| if (job_ptr->array_task_str) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u_[%s] (%u)", |
| job_ptr->array_job_id, job_ptr->array_task_str, |
| job_ptr->job_id); |
| } else if (job_ptr->array_task_id != NO_VAL) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u_%u (%u)", |
| job_ptr->array_job_id, job_ptr->array_task_id, |
| job_ptr->job_id); |
| } else if (job_ptr->het_job_id) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u+%u (%u)", |
| job_ptr->het_job_id, |
| job_ptr->het_job_offset, |
| job_ptr->job_id); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->job_id); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_JOBID), |
| tmp_char); |
| |
| slurm_make_time_str(&job_ptr->last_sched_eval, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_LAST_SCHED_EVAL), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_LICENSES), |
| job_ptr->licenses); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_MCS_LABEL), |
| (job_ptr->mcs_label==NULL) ? "N/A" : |
| job_ptr->mcs_label); |
| |
| convert_num_unit((float)job_ptr->pn_min_cpus, tmp_char, |
| sizeof(tmp_char), UNIT_NONE, NO_VAL, |
| working_sview_config.convert_flags); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPU_REQ), |
| tmp_char); |
| |
| min_mem = job_ptr->pn_min_memory; |
| if (min_mem & MEM_PER_CPU) |
| min_mem &= (~MEM_PER_CPU); |
| |
| if (min_mem > 0) { |
| int len; |
| convert_num_unit((float)min_mem, tmp_char, sizeof(tmp_char), |
| UNIT_MEGA, NO_VAL, |
| working_sview_config.convert_flags); |
| len = strlen(tmp_char); |
| if (job_ptr->mem_per_tres) { |
| sprintf(tmp_char+len, " Per TRES"); |
| } else if (job_ptr->pn_min_memory & MEM_PER_CPU) |
| sprintf(tmp_char+len, " Per CPU"); |
| else |
| sprintf(tmp_char+len, " Per Node"); |
| } else |
| sprintf(tmp_char, " "); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_MEM_MIN), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_MEM_PER_TRES), |
| job_ptr->mem_per_tres); |
| |
| if (job_ptr->pn_min_tmp_disk > 0) |
| convert_num_unit((float)job_ptr->pn_min_tmp_disk, tmp_char, |
| sizeof(tmp_char), UNIT_MEGA, NO_VAL, |
| working_sview_config.convert_flags); |
| else |
| sprintf(tmp_char, " "); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TMP_DISK), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NAME), |
| job_ptr->name); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NETWORK), |
| job_ptr->network); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%"PRIi64, |
| (((int64_t)job_ptr->nice) - NICE_OFFSET)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NICE), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODELIST), |
| nodes); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODELIST_EXC), |
| job_ptr->exc_nodes); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODELIST_REQ), |
| job_ptr->req_nodes); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODELIST_SCHED), |
| job_ptr->sched_nodes); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| sview_job_info_ptr->node_cnt); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODES), |
| tmp_char); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->max_nodes); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODES_MAX), |
| tmp_char); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| sview_job_info_ptr->node_cnt); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODES_MIN), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_OVER_SUBSCRIBE), |
| job_share_string(job_ptr->shared)); |
| |
| if (job_ptr->het_job_id) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| job_ptr->het_job_id); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "N/A"); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_HET_JOB_ID), |
| tmp_char); |
| |
| if (job_ptr->het_job_offset) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u", |
| job_ptr->het_job_offset); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "N/A"); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_HET_JOB_OFFSET), |
| tmp_char); |
| |
| if (job_ptr->het_job_id_set) { |
| snprintf(tmp_char, sizeof(tmp_char), "%s", |
| job_ptr->het_job_id_set); |
| } else { |
| snprintf(tmp_char, sizeof(tmp_char), "N/A"); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_HET_JOB_ID_SET), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_PARTITION), |
| job_ptr->partition); |
| |
| if (job_ptr->preempt_time) { |
| slurm_make_time_str((time_t *)&job_ptr->preempt_time, tmp_char, |
| sizeof(tmp_char)); |
| } else |
| sprintf(tmp_char, "N/A"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_PREEMPT_TIME), |
| tmp_char); |
| |
| sprintf(tmp_char, "%u", job_ptr->priority); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_PRIORITY), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_QOS), |
| job_ptr->qos); |
| |
| if (job_ptr->state_desc) |
| reason = job_ptr->state_desc; |
| else |
| reason = job_state_reason_string(job_ptr->state_reason); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_REASON), reason); |
| |
| if (job_ptr->reboot) |
| sprintf(tmp_char, "yes"); |
| else |
| sprintf(tmp_char, "no"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_REBOOT), |
| tmp_char); |
| |
| if (job_ptr->requeue) |
| sprintf(tmp_char, "yes"); |
| else |
| sprintf(tmp_char, "no"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_REQUEUE), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_RESV_NAME), |
| job_ptr->resv_name); |
| |
| snprintf(tmp_char, sizeof(tmp_char), "%u", job_ptr->restart_cnt); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_RESTARTS), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_STATE), |
| job_state_string(job_ptr->job_state)); |
| |
| slurm_get_job_stderr(tmp1, sizeof(tmp1), job_ptr); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_STD_ERR), |
| tmp1); |
| |
| slurm_get_job_stdin(tmp1, sizeof(tmp1), job_ptr); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_STD_IN), |
| tmp1); |
| |
| slurm_get_job_stdout(tmp1, sizeof(tmp1), job_ptr); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_STD_OUT), |
| tmp1); |
| |
| secs2time_str((time_t) job_ptr->wait4switch, time_buf, |
| sizeof(time_buf)); |
| snprintf(tmp_char, sizeof(tmp_char), "%u@%s", |
| job_ptr->req_switch, time_buf); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_SWITCHES), |
| tmp_char); |
| |
| if ((job_ptr->core_spec == NO_VAL16) || |
| ((job_ptr->core_spec & CORE_SPEC_THREAD) == 0)) { |
| sprintf(tmp_char, "N/A"); |
| } else { |
| sprintf(tmp_char, "%u", |
| job_ptr->core_spec & (~CORE_SPEC_THREAD)); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_THREAD_SPEC), |
| tmp_char); |
| |
| slurm_make_time_str((time_t *)&job_ptr->accrue_time, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_ACCRUE), |
| tmp_char); |
| slurm_make_time_str((time_t *)&job_ptr->eligible_time, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_ELIGIBLE), |
| tmp_char); |
| if ((job_ptr->time_limit == INFINITE) && |
| (job_ptr->end_time > time(NULL))) |
| sprintf(tmp_char, "Unknown"); |
| else |
| slurm_make_time_str((time_t *)&job_ptr->end_time, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_END), |
| tmp_char); |
| |
| if (job_ptr->time_limit == NO_VAL) |
| sprintf(tmp_char, "Partition Limit"); |
| else if (job_ptr->time_limit == INFINITE) |
| sprintf(tmp_char, "Infinite"); |
| else |
| secs2time_str((job_ptr->time_limit * 60), |
| tmp_char, sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIMELIMIT), |
| tmp_char); |
| |
| if (job_ptr->resize_time) { |
| slurm_make_time_str((time_t *)&job_ptr->resize_time, tmp_char, |
| sizeof(tmp_char)); |
| } else |
| sprintf(tmp_char, "N/A"); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_RESIZE), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_RUNNING), |
| running_char); |
| |
| slurm_make_time_str((time_t *)&job_ptr->start_time, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_START), |
| tmp_char); |
| slurm_make_time_str((time_t *)&job_ptr->submit_time, tmp_char, |
| sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_SUBMIT), |
| tmp_char); |
| secs2time_str(suspend_secs, tmp_char, sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_SUSPEND), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_ALLOC), |
| job_ptr->tres_alloc_str); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_BIND), |
| job_ptr->tres_bind); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_FREQ), |
| job_ptr->tres_freq); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_JOB), |
| job_ptr->tres_per_job); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_NODE), |
| job_ptr->tres_per_node); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_SOCKET), |
| job_ptr->tres_per_socket); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_TASK), |
| job_ptr->tres_per_task); |
| |
| uname = uid_to_string_cached((uid_t)job_ptr->user_id); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_USER_ID), uname); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_WCKEY), |
| job_ptr->wckey); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_WORKDIR), |
| job_ptr->work_dir); |
| |
| xfree(nodes); |
| } |
| |
| static void _update_job_record(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeStore *treestore, |
| GtkTreeIter *iter, bool check_task, |
| bool handle_pending) |
| { |
| char tmp_array_job_id[20], tmp_array_task_id[20]; |
| char tmp_time_run[40], tmp_time_resize[256], tmp_time_submit[256]; |
| char tmp_time_elig[256], tmp_time_start[256], tmp_time_end[256]; |
| char tmp_time_sus[40], tmp_time_limit[40], tmp_alloc_node[40]; |
| char tmp_exit[40], tmp_derived_ec[40]; |
| char tmp_cpu_cnt[40], tmp_node_cnt[40], tmp_disk[40]; |
| char tmp_cpus_max[40], tmp_mem_min[40], tmp_cpu_req[40]; |
| char tmp_nodes_min[40], tmp_nodes_max[40], tmp_cpus_per_task[40]; |
| char tmp_prio[40], tmp_nice[40], tmp_preempt_time[256]; |
| char tmp_rqswitch[40], tmp_core_spec[40], tmp_job_id[40]; |
| char tmp_std_err[128], tmp_std_in[128], tmp_std_out[128]; |
| char tmp_thread_spec[40], tmp_time_deadline[256], tmp_het_job_id[40]; |
| char tmp_het_job_id_set[40], tmp_het_job_offset[40]; |
| char tmp_time_accrue[256]; |
| char *tmp_batch, *tmp_cont, *tmp_requeue, *tmp_uname, *tmp_gname; |
| char *tmp_reboot,*tmp_nodes; |
| const char *tmp_reason; |
| char time_buf[32]; |
| time_t now_time = time(NULL); |
| int suspend_secs = 0; |
| GtkTreeIter step_iter; |
| job_info_t *job_ptr = sview_job_info_ptr->job_ptr; |
| uint16_t term_code = 0, term_sig = 0; |
| uint64_t min_mem = 0; |
| |
| if (!iter) |
| iter = &sview_job_info_ptr->iter_ptr; |
| |
| snprintf(tmp_alloc_node, sizeof(tmp_alloc_node), "%s:%u", |
| job_ptr->alloc_node, job_ptr->alloc_sid); |
| |
| /* |
| * These need to be set up first, or they could be NULL when |
| * they need to be set. Since we do a xstrcmp on these later |
| * we need to make sure they are exactly the same (length wise). |
| */ |
| if (!sview_job_info_ptr->task_hl_str && sview_job_info_ptr->task_hl) { |
| sview_job_info_ptr->task_hl_str = |
| hostlist_ranged_string_xmalloc( |
| sview_job_info_ptr->task_hl); |
| if (!job_ptr->het_job_id) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u_%s", |
| job_ptr->array_job_id, |
| sview_job_info_ptr->task_hl_str); |
| } else { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u+%s", |
| job_ptr->het_job_id, |
| sview_job_info_ptr->task_hl_str); |
| } |
| xfree(sview_job_info_ptr->task_hl_str); |
| sview_job_info_ptr->task_hl_str = xstrdup(tmp_job_id); |
| } |
| |
| if (!sview_job_info_ptr->task_pending_hl_str |
| && sview_job_info_ptr->task_pending_hl) { |
| sview_job_info_ptr->task_pending_hl_str = |
| hostlist_ranged_string_xmalloc( |
| sview_job_info_ptr->task_pending_hl); |
| if (!job_ptr->het_job_id) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u_%s", |
| job_ptr->array_job_id, |
| sview_job_info_ptr->task_pending_hl_str); |
| } else { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u+%s", |
| job_ptr->het_job_id, |
| sview_job_info_ptr->task_pending_hl_str); |
| } |
| xfree(sview_job_info_ptr->task_pending_hl_str); |
| sview_job_info_ptr->task_pending_hl_str = |
| xstrdup(tmp_job_id); |
| } |
| |
| if (handle_pending && |
| (job_ptr->het_job_id || job_ptr->array_job_id)) { |
| if (job_ptr->array_task_str || |
| (job_ptr->array_task_id != NO_VAL)) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->task_pending_hl_str); |
| snprintf(tmp_array_job_id, |
| sizeof(tmp_array_job_id), "N/A"); |
| snprintf(tmp_array_task_id, |
| sizeof(tmp_array_task_id), "%s", |
| sview_job_info_ptr->task_pending_hl_str); |
| } else if (job_ptr->het_job_id) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->task_pending_hl_str); |
| } |
| } else if (check_task && |
| (job_ptr->het_job_id || job_ptr->array_job_id)) { |
| if (job_ptr->array_task_str || |
| (job_ptr->array_task_id != NO_VAL)) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->task_hl_str); |
| snprintf(tmp_array_job_id, |
| sizeof(tmp_array_job_id), "N/A"); |
| snprintf(tmp_array_task_id, |
| sizeof(tmp_array_task_id), "%s", |
| sview_job_info_ptr->task_hl_str); |
| } else if (job_ptr->het_job_id) |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->task_hl_str); |
| } else if (job_ptr->array_task_str) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->job_id_str); |
| snprintf(tmp_array_job_id, sizeof(tmp_array_job_id), "%u", |
| job_ptr->array_job_id); |
| snprintf(tmp_array_task_id, sizeof(tmp_array_task_id), "[%s]", |
| job_ptr->array_task_str); |
| } else if (job_ptr->array_task_id != NO_VAL) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->job_id_str); |
| snprintf(tmp_array_job_id, sizeof(tmp_array_job_id), "%u", |
| job_ptr->array_job_id); |
| snprintf(tmp_array_task_id, sizeof(tmp_array_task_id), "%u", |
| job_ptr->array_task_id); |
| } else if (job_ptr->het_job_id) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->job_id_str); |
| snprintf(tmp_het_job_id, sizeof(tmp_het_job_id), |
| "%u", job_ptr->het_job_id); |
| snprintf(tmp_het_job_id_set, sizeof(tmp_het_job_id_set), |
| "%s", job_ptr->het_job_id_set); |
| snprintf(tmp_het_job_offset, sizeof(tmp_het_job_offset), |
| "%u", job_ptr->het_job_offset); |
| } else { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%s", |
| sview_job_info_ptr->job_id_str); |
| } |
| |
| |
| if (!job_ptr->het_job_id) { |
| snprintf(tmp_het_job_id, |
| sizeof(tmp_het_job_id), "N/A"); |
| snprintf(tmp_het_job_id_set, |
| sizeof(tmp_het_job_id_set), "N/A"); |
| snprintf(tmp_het_job_offset, |
| sizeof(tmp_het_job_offset), "N/A"); |
| } |
| |
| if (!job_ptr->array_job_id) { |
| snprintf(tmp_array_job_id, |
| sizeof(tmp_array_job_id), "N/A"); |
| snprintf(tmp_array_task_id, |
| sizeof(tmp_array_task_id), "N/A"); |
| } |
| |
| if (job_ptr->batch_flag) |
| tmp_batch = "yes"; |
| else |
| tmp_batch = "no"; |
| |
| if (job_ptr->contiguous) |
| tmp_cont = "yes"; |
| else |
| tmp_cont = "no"; |
| |
| if ((job_ptr->core_spec == NO_VAL16) || |
| (job_ptr->core_spec & CORE_SPEC_THREAD)) { |
| sprintf(tmp_core_spec, "N/A"); |
| } else { |
| sprintf(tmp_core_spec, "%u", job_ptr->core_spec); |
| } |
| if ((job_ptr->core_spec == NO_VAL16) || |
| ((job_ptr->core_spec & CORE_SPEC_THREAD) == 0)) { |
| sprintf(tmp_thread_spec, "N/A"); |
| } else { |
| sprintf(tmp_thread_spec, "%u", |
| job_ptr->core_spec & (~CORE_SPEC_THREAD)); |
| } |
| |
| |
| if (job_ptr->cpus_per_task == NO_VAL16) |
| sprintf(tmp_cpus_per_task, "N/A"); |
| else |
| sprintf(tmp_cpus_per_task, "%u", job_ptr->cpus_per_task); |
| |
| snprintf(tmp_cpu_cnt, sizeof(tmp_cpu_cnt), "%u", job_ptr->num_cpus); |
| convert_num_unit((float)job_ptr->pn_min_cpus, tmp_cpu_req, |
| sizeof(tmp_cpu_req), UNIT_NONE, NO_VAL, |
| working_sview_config.convert_flags); |
| |
| snprintf(tmp_cpus_max, sizeof(tmp_cpus_max), "%u", |
| job_ptr->max_cpus); |
| convert_num_unit((float)job_ptr->pn_min_tmp_disk, tmp_disk, |
| sizeof(tmp_disk), UNIT_MEGA, NO_VAL, |
| working_sview_config.convert_flags); |
| |
| if (WIFEXITED(job_ptr->derived_ec)) |
| term_code = WEXITSTATUS(job_ptr->derived_ec); |
| else |
| term_code = 0; |
| if (WIFSIGNALED(job_ptr->derived_ec)) |
| term_sig = WTERMSIG(job_ptr->derived_ec); |
| else |
| term_sig = 0; |
| snprintf(tmp_derived_ec, sizeof(tmp_derived_ec), "%u:%u", |
| term_code, term_sig); |
| |
| if (WIFEXITED(job_ptr->exit_code)) |
| term_code = WEXITSTATUS(job_ptr->exit_code); |
| else |
| term_code = 0; |
| if (WIFSIGNALED(job_ptr->exit_code)) |
| term_sig = WTERMSIG(job_ptr->exit_code); |
| else |
| term_sig = 0; |
| snprintf(tmp_exit, sizeof(tmp_exit), "%u:%u", term_code, term_sig); |
| |
| tmp_gname = gid_to_string(job_ptr->group_id); |
| |
| min_mem = job_ptr->pn_min_memory; |
| if (min_mem & MEM_PER_CPU) |
| min_mem &= (~MEM_PER_CPU); |
| |
| if (min_mem > 0) { |
| int len; |
| convert_num_unit((float)min_mem, tmp_mem_min, |
| sizeof(tmp_mem_min), UNIT_MEGA, NO_VAL, |
| working_sview_config.convert_flags); |
| len = strlen(tmp_mem_min); |
| if (job_ptr->mem_per_tres) { |
| sprintf(tmp_mem_min+len, " Per TRES"); |
| } else if (job_ptr->pn_min_memory & MEM_PER_CPU) |
| sprintf(tmp_mem_min+len, " Per CPU"); |
| else |
| sprintf(tmp_mem_min+len, " Per Node"); |
| } else |
| sprintf(tmp_mem_min, " "); |
| |
| sprintf(tmp_node_cnt, "%u", sview_job_info_ptr->node_cnt); |
| |
| sprintf(tmp_nodes_min, "%u", sview_job_info_ptr->node_cnt); |
| |
| if (job_ptr->state_desc) |
| tmp_reason = job_ptr->state_desc; |
| else |
| tmp_reason = job_state_reason_string(job_ptr->state_reason); |
| |
| if (job_ptr->reboot) |
| tmp_reboot = "yes"; |
| else |
| tmp_reboot = "no"; |
| |
| if (job_ptr->requeue) |
| tmp_requeue = "yes"; |
| else |
| tmp_requeue = "no"; |
| |
| snprintf(tmp_nice, sizeof(tmp_nice), "%"PRIi64, |
| (((int64_t)job_ptr->nice) - NICE_OFFSET)); |
| |
| if (!job_ptr->nodes || IS_JOB_PENDING(job_ptr) || |
| !xstrcasecmp(job_ptr->nodes,"waiting...")) { |
| sprintf(tmp_time_run,"00:00:00"); |
| tmp_nodes = xstrdup("waiting..."); |
| } else { |
| if (IS_JOB_SUSPENDED(job_ptr)) |
| now_time = job_ptr->pre_sus_time; |
| else { |
| if (!IS_JOB_RUNNING(job_ptr) && |
| (job_ptr->end_time != 0)) |
| now_time = job_ptr->end_time; |
| if (job_ptr->suspend_time) { |
| now_time = (time_t) |
| (difftime(now_time, |
| job_ptr->suspend_time) |
| + job_ptr->pre_sus_time); |
| } else |
| now_time = (time_t)difftime( |
| now_time, job_ptr->start_time); |
| } |
| suspend_secs = (time(NULL) - job_ptr->start_time) - now_time; |
| secs2time_str(now_time, tmp_time_run, sizeof(tmp_time_run)); |
| tmp_nodes = slurm_sort_node_list_str(sview_job_info_ptr->nodes); |
| } |
| |
| if (job_ptr->max_nodes > 0) |
| sprintf(tmp_nodes_max, "%u", sview_job_info_ptr->node_cnt); |
| else |
| tmp_nodes_max[0] = '\0'; |
| |
| sprintf(tmp_prio, "%u", job_ptr->priority); |
| |
| slurm_make_time_str((time_t *)&job_ptr->accrue_time, tmp_time_accrue, |
| sizeof(tmp_time_accrue)); |
| |
| slurm_make_time_str((time_t *)&job_ptr->eligible_time, tmp_time_elig, |
| sizeof(tmp_time_elig)); |
| |
| if ((job_ptr->time_limit == INFINITE) && |
| (job_ptr->end_time > time(NULL))) |
| sprintf(tmp_time_end, "Unknown"); |
| else |
| slurm_make_time_str((time_t *)&job_ptr->end_time, tmp_time_end, |
| sizeof(tmp_time_end)); |
| |
| if (job_ptr->time_limit == NO_VAL) |
| sprintf(tmp_time_limit, "Partition Limit"); |
| else if (job_ptr->time_limit == INFINITE) |
| sprintf(tmp_time_limit, "Infinite"); |
| else |
| secs2time_str((job_ptr->time_limit * 60), |
| tmp_time_limit, sizeof(tmp_time_limit)); |
| |
| if (job_ptr->preempt_time) { |
| slurm_make_time_str((time_t *)&job_ptr->preempt_time, |
| tmp_preempt_time, sizeof(tmp_preempt_time)); |
| } else |
| sprintf(tmp_preempt_time, "N/A"); |
| |
| if (job_ptr->resize_time) { |
| slurm_make_time_str((time_t *)&job_ptr->resize_time, |
| tmp_time_resize, sizeof(tmp_time_resize)); |
| } else |
| sprintf(tmp_time_resize, "N/A"); |
| |
| slurm_make_time_str((time_t *)&job_ptr->start_time, tmp_time_start, |
| sizeof(tmp_time_start)); |
| |
| slurm_make_time_str((time_t *)&job_ptr->submit_time, tmp_time_submit, |
| sizeof(tmp_time_submit)); |
| |
| if (job_ptr->deadline) |
| slurm_make_time_str((time_t *)&job_ptr->deadline, |
| tmp_time_deadline, |
| sizeof(tmp_time_deadline)); |
| else |
| sprintf(tmp_time_deadline, "N/A"); |
| |
| slurm_get_job_stderr(tmp_std_err, sizeof(tmp_std_err), job_ptr); |
| |
| slurm_get_job_stdin(tmp_std_in, sizeof(tmp_std_in), job_ptr); |
| |
| slurm_get_job_stdout(tmp_std_out, sizeof(tmp_std_out), job_ptr); |
| |
| secs2time_str(suspend_secs, tmp_time_sus, sizeof(tmp_time_sus)); |
| |
| if (job_ptr->req_switch != NO_VAL) { |
| if (job_ptr->wait4switch != NO_VAL) { |
| secs2time_str((time_t) job_ptr->wait4switch, time_buf, |
| sizeof(time_buf)); |
| sprintf(tmp_rqswitch, "%u@%s", |
| job_ptr->req_switch, time_buf); |
| } else { |
| sprintf(tmp_rqswitch, "%u", job_ptr->req_switch); |
| } |
| |
| } else { |
| sprintf(tmp_rqswitch, "N/A"); |
| } |
| |
| tmp_uname = uid_to_string_cached((uid_t)job_ptr->user_id); |
| |
| if ((handle_pending || check_task) && |
| (job_ptr->array_task_str || (job_ptr->array_task_id != NO_VAL) || |
| job_ptr->het_job_id)) { |
| gtk_tree_store_set(treestore, iter, |
| SORTID_ACCOUNT, job_ptr->account, |
| SORTID_ALLOC, 1, |
| SORTID_ALLOC_NODE, tmp_alloc_node, |
| SORTID_ARRAY_JOB_ID, tmp_array_job_id, |
| SORTID_ARRAY_TASK_ID,tmp_array_task_id, |
| SORTID_BATCH, tmp_batch, |
| SORTID_BATCH_HOST, job_ptr->batch_host, |
| SORTID_BURST_BUFFER, job_ptr->burst_buffer, |
| SORTID_CLUSTER_NAME, job_ptr->cluster, |
| SORTID_COLOR, |
| sview_colors[sview_job_info_ptr->color_inx], |
| SORTID_COLOR_INX, |
| sview_job_info_ptr->color_inx, |
| SORTID_COMMAND, job_ptr->command, |
| SORTID_COMMENT, job_ptr->comment, |
| SORTID_CONTIGUOUS, tmp_cont, |
| SORTID_EXTRA, job_ptr->extra, |
| SORTID_JOBID, tmp_job_id, |
| SORTID_JOBID_FORMATTED, tmp_job_id, |
| SORTID_HET_JOB_ID, tmp_het_job_id, |
| SORTID_HET_JOB_ID_SET, tmp_het_job_id_set, |
| SORTID_HET_JOB_OFFSET, tmp_het_job_offset, |
| SORTID_PARTITION, job_ptr->partition, |
| SORTID_UPDATED, 1, |
| SORTID_USER_ID, tmp_uname, |
| -1); |
| if (handle_pending) |
| gtk_tree_store_set(treestore, iter, |
| SORTID_ACCOUNT, job_ptr->account, |
| SORTID_STATE, |
| job_state_string(JOB_PENDING), |
| -1); |
| } else { |
| gtk_tree_store_set(treestore, iter, |
| SORTID_ACCOUNT, job_ptr->account, |
| SORTID_ALLOC, 1, |
| SORTID_ALLOC_NODE, tmp_alloc_node, |
| SORTID_ARRAY_JOB_ID, tmp_array_job_id, |
| SORTID_ARRAY_TASK_ID,tmp_array_task_id, |
| SORTID_BATCH, tmp_batch, |
| SORTID_BATCH_HOST, job_ptr->batch_host, |
| SORTID_BURST_BUFFER, job_ptr->burst_buffer, |
| SORTID_CLUSTER_NAME, job_ptr->cluster, |
| SORTID_COLOR, |
| sview_colors[sview_job_info_ptr->color_inx], |
| SORTID_COLOR_INX, |
| sview_job_info_ptr->color_inx, |
| SORTID_COMMAND, job_ptr->command, |
| SORTID_COMMENT, job_ptr->comment, |
| SORTID_CONTIGUOUS, tmp_cont, |
| SORTID_CORE_SPEC, tmp_core_spec, |
| SORTID_CPUS, tmp_cpu_cnt, |
| SORTID_CPU_MAX, tmp_cpus_max, |
| SORTID_CPU_MIN, tmp_cpu_cnt, |
| SORTID_CPUS_PER_TASK,tmp_cpus_per_task, |
| SORTID_CPUS_PER_TRES,job_ptr->cpus_per_tres, |
| SORTID_CPU_REQ, tmp_cpu_req, |
| SORTID_DEADLINE, tmp_time_deadline, |
| SORTID_DEPENDENCY, job_ptr->dependency, |
| SORTID_DERIVED_EC, tmp_derived_ec, |
| SORTID_EXIT_CODE, tmp_exit, |
| SORTID_EXTRA, job_ptr->extra, |
| SORTID_FEATURES, job_ptr->features, |
| SORTID_PREFER, job_ptr->prefer, |
| SORTID_FED_ACTIVE_SIBS, |
| job_ptr->fed_siblings_active_str, |
| SORTID_FED_ORIGIN, job_ptr->fed_origin_str, |
| SORTID_FED_VIABLE_SIBS, |
| job_ptr->fed_siblings_viable_str, |
| SORTID_GROUP_ID, tmp_gname, |
| SORTID_JOBID, tmp_job_id, |
| SORTID_JOBID_FORMATTED, tmp_job_id, |
| SORTID_LICENSES, job_ptr->licenses, |
| SORTID_MCS_LABEL, job_ptr->mcs_label, |
| SORTID_MEM_MIN, tmp_mem_min, |
| SORTID_MEM_PER_TRES, job_ptr->cpus_per_tres, |
| SORTID_NAME, job_ptr->name, |
| SORTID_NICE, tmp_nice, |
| SORTID_NODE_INX, job_ptr->node_inx, |
| SORTID_NODELIST, tmp_nodes, |
| SORTID_NODELIST_EXC, job_ptr->exc_nodes, |
| SORTID_NODELIST_REQ, job_ptr->req_nodes, |
| SORTID_NODELIST_SCHED, |
| job_ptr->sched_nodes, |
| SORTID_NODES, tmp_node_cnt, |
| SORTID_NODES_MAX, tmp_nodes_max, |
| SORTID_NODES_MIN, tmp_nodes_min, |
| SORTID_OVER_SUBSCRIBE, |
| job_share_string(job_ptr->shared), |
| SORTID_HET_JOB_ID, tmp_het_job_id, |
| SORTID_HET_JOB_ID_SET, tmp_het_job_id_set, |
| SORTID_HET_JOB_OFFSET, tmp_het_job_offset, |
| SORTID_PARTITION, job_ptr->partition, |
| SORTID_PREEMPT_TIME, tmp_preempt_time, |
| SORTID_PRIORITY, tmp_prio, |
| SORTID_QOS, job_ptr->qos, |
| SORTID_REASON, tmp_reason, |
| SORTID_REBOOT, tmp_reboot, |
| SORTID_REQUEUE, tmp_requeue, |
| SORTID_RESTARTS, job_ptr->restart_cnt, |
| SORTID_RESV_NAME, job_ptr->resv_name, |
| SORTID_STATE, |
| job_state_string(job_ptr->job_state), |
| SORTID_STATE_NUM, job_ptr->job_state, |
| SORTID_STD_ERR, tmp_std_err, |
| SORTID_STD_IN, tmp_std_in, |
| SORTID_STD_OUT, tmp_std_out, |
| SORTID_SWITCHES, tmp_rqswitch, |
| SORTID_THREAD_SPEC, tmp_thread_spec, |
| SORTID_TIME_ACCRUE, tmp_time_accrue, |
| SORTID_TIME_ELIGIBLE,tmp_time_elig, |
| SORTID_TIME_END, tmp_time_end, |
| SORTID_TIME_RESIZE, tmp_time_resize, |
| SORTID_TIME_RUNNING, tmp_time_run, |
| SORTID_TIME_START, tmp_time_start, |
| SORTID_TIME_SUBMIT, tmp_time_submit, |
| SORTID_TIME_SUSPEND, tmp_time_sus, |
| SORTID_TIMELIMIT, tmp_time_limit, |
| SORTID_TMP_DISK, tmp_disk, |
| SORTID_TRES_ALLOC, job_ptr->tres_alloc_str, |
| SORTID_TRES_BIND, job_ptr->tres_bind, |
| SORTID_TRES_FREQ, job_ptr->tres_freq, |
| SORTID_TRES_PER_JOB, job_ptr->tres_per_job, |
| SORTID_TRES_PER_NODE,job_ptr->tres_per_node, |
| SORTID_TRES_PER_SOCKET, |
| job_ptr->tres_per_socket, |
| SORTID_TRES_PER_TASK,job_ptr->tres_per_task, |
| SORTID_UPDATED, 1, |
| SORTID_USER_ID, tmp_uname, |
| SORTID_WCKEY, job_ptr->wckey, |
| SORTID_WORKDIR, job_ptr->work_dir, |
| -1); |
| } |
| |
| gtk_tree_store_set(treestore, iter, |
| SORTID_NETWORK, job_ptr->network, -1); |
| |
| if (check_task && |
| (job_ptr->array_task_str || |
| ((job_ptr->array_task_id != NO_VAL) || job_ptr->het_job_id))) { |
| if (gtk_tree_model_iter_children(GTK_TREE_MODEL(treestore), |
| &step_iter, |
| iter)) |
| _update_info_task(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), &step_iter, |
| iter, false); |
| else |
| _update_info_task(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), NULL, |
| iter, false); |
| } else if (handle_pending && |
| (job_ptr->array_task_str || |
| (job_ptr->array_task_id != NO_VAL || |
| job_ptr->het_job_id))) { |
| if (gtk_tree_model_iter_children(GTK_TREE_MODEL(treestore), |
| &step_iter, |
| iter)) |
| _update_info_task(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), &step_iter, |
| iter, true); |
| else |
| _update_info_task(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), NULL, |
| iter, true); |
| } else { |
| if (gtk_tree_model_iter_children(GTK_TREE_MODEL(treestore), |
| &step_iter, |
| iter)) |
| _update_info_step(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), &step_iter, |
| iter); |
| else |
| _update_info_step(sview_job_info_ptr, |
| GTK_TREE_MODEL(treestore), NULL, |
| iter); |
| } |
| |
| xfree(tmp_gname); |
| xfree(tmp_nodes); |
| |
| return; |
| } |
| |
| static int _id_from_stepstr(char *str) { |
| char *end = NULL; |
| int id = strtol(str, &end, 10); |
| /* if no digits found, it must be text */ |
| if (end == str) { |
| if (!strcasecmp(str, "TBD")) |
| id = SLURM_PENDING_STEP; |
| else if (!strcasecmp(str, "Batch")) |
| id = SLURM_BATCH_SCRIPT; |
| else if (!strcasecmp(str, "Extern")) |
| id = SLURM_EXTERN_CONT; |
| else if (!strcasecmp(str, "Interactive")) |
| id = SLURM_INTERACTIVE_STEP; |
| else |
| id = NO_VAL; |
| } |
| return id; |
| } |
| |
| static void _stepstr_from_step(job_step_info_t *step_ptr, char *dest, |
| uint32_t len) { |
| if (step_ptr->step_id.step_id == SLURM_PENDING_STEP) |
| snprintf(dest, len, "TBD"); |
| else if (step_ptr->step_id.step_id == SLURM_EXTERN_CONT) |
| snprintf(dest, len, "Extern"); |
| else if (step_ptr->step_id.step_id == SLURM_INTERACTIVE_STEP) |
| snprintf(dest, len, "Interactive"); |
| else if (step_ptr->step_id.step_id == SLURM_BATCH_SCRIPT) |
| snprintf(dest, len, "Batch"); |
| else |
| snprintf(dest, len, "%u", |
| step_ptr->step_id.step_id); |
| } |
| |
| static void _layout_step_record(GtkTreeView *treeview, |
| job_step_info_t *step_ptr, |
| int update, bool suspended) |
| { |
| char *uname; |
| char *tmp_nodes; |
| char tmp_char[100], tmp_str[50], tmp_time[50]; |
| GtkTreeIter iter; |
| uint32_t state; |
| GtkTreeStore *treestore = |
| GTK_TREE_STORE(gtk_tree_view_get_model(treeview)); |
| |
| if (!treestore) |
| return; |
| |
| convert_num_unit((float)step_ptr->num_cpus, tmp_char, sizeof(tmp_char), |
| UNIT_NONE, NO_VAL, working_sview_config.convert_flags); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPUS), |
| tmp_char); |
| |
| uname = uid_to_string_cached((uid_t)step_ptr->user_id); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_USER_ID), uname); |
| |
| if (step_ptr->array_job_id) { |
| snprintf(tmp_char, sizeof(tmp_char), "%u_%u.%u (%u.%u)", |
| step_ptr->array_job_id, step_ptr->array_task_id, |
| step_ptr->step_id.step_id, |
| step_ptr->step_id.job_id, step_ptr->step_id.step_id); |
| // } else if (step_ptr->het_job_id) { |
| // snprintf(tmp_char, sizeof(tmp_char), "%u+%u.%u (%u.%u)", |
| // step_ptr->het_job_id, step_ptr->het_job_offset, |
| // step_ptr->step_id.step_id, |
| // step_ptr->step_id.job_id, step_ptr->step_id.step_id); |
| } else { |
| _stepstr_from_step(step_ptr, tmp_str, sizeof(tmp_str)); |
| snprintf(tmp_char, sizeof(tmp_char), "%u.%s", |
| step_ptr->step_id.job_id, tmp_str); |
| } |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_JOBID), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_CPUS_PER_TRES), |
| step_ptr->cpus_per_tres); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_MEM_PER_TRES), |
| step_ptr->mem_per_tres); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_BIND), |
| step_ptr->tres_bind); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_FREQ), |
| step_ptr->tres_freq); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_JOB), |
| step_ptr->tres_per_step); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_NODE), |
| step_ptr->tres_per_node); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_SOCKET), |
| step_ptr->tres_per_socket); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_PER_TASK), |
| step_ptr->tres_per_task); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NAME), |
| step_ptr->name); |
| |
| |
| if (suspended) |
| state = JOB_SUSPENDED; |
| else |
| state = step_ptr->state; |
| |
| if (!step_ptr->nodes |
| || !xstrcasecmp(step_ptr->nodes, "waiting...")) { |
| sprintf(tmp_time,"00:00:00"); |
| tmp_nodes = xstrdup("waiting..."); |
| state = JOB_PENDING; |
| } else { |
| secs2time_str(step_ptr->run_time, tmp_time, sizeof(tmp_time)); |
| tmp_nodes = slurm_sort_node_list_str(step_ptr->nodes); |
| convert_num_unit((float)_nodes_in_list(tmp_nodes), |
| tmp_char, sizeof(tmp_char), UNIT_NONE, |
| NO_VAL, |
| working_sview_config.convert_flags); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODES), |
| tmp_char); |
| } |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_NODELIST), |
| tmp_nodes); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_PARTITION), |
| step_ptr->partition); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_STATE), |
| job_state_string(state)); |
| |
| if (step_ptr->time_limit == NO_VAL) |
| sprintf(tmp_char, "Partition Limit"); |
| else if (step_ptr->time_limit == INFINITE) |
| sprintf(tmp_char, "Infinite"); |
| else |
| secs2time_str((step_ptr->time_limit * 60), |
| tmp_char, sizeof(tmp_char)); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIMELIMIT), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TIME_RUNNING), |
| tmp_time); |
| |
| convert_num_unit((float)step_ptr->num_tasks, tmp_char, sizeof(tmp_char), |
| UNIT_NONE, NO_VAL, working_sview_config.convert_flags); |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TASKS), |
| tmp_char); |
| |
| add_display_treestore_line(update, treestore, &iter, |
| find_col_name(display_data_job, |
| SORTID_TRES_ALLOC), |
| step_ptr->tres_fmt_alloc_str); |
| |
| xfree(tmp_nodes); |
| } |
| |
| static void _update_step_record(job_step_info_t *step_ptr, |
| GtkTreeStore *treestore, |
| GtkTreeIter *iter, bool suspended) |
| { |
| char *tmp_uname; |
| char *tmp_nodes; |
| char tmp_cpu_min[40], tmp_time_run[40], tmp_time_limit[40]; |
| char tmp_node_cnt[40], tmp_time_start[256], tmp_task_cnt[40]; |
| char tmp_step_id[40], tmp_job_id[400]; |
| char tmp_fmt_stepid[40]; |
| uint32_t state; |
| int color_inx = step_ptr->step_id.step_id % sview_colors_cnt; |
| |
| convert_num_unit((float)step_ptr->num_cpus, tmp_cpu_min, |
| sizeof(tmp_cpu_min), UNIT_NONE, NO_VAL, |
| working_sview_config.convert_flags); |
| |
| if (suspended) |
| state = JOB_SUSPENDED; |
| else |
| state = step_ptr->state; |
| |
| if (!step_ptr->nodes || |
| !xstrcasecmp(step_ptr->nodes,"waiting...")) { |
| sprintf(tmp_time_run, "00:00:00"); |
| tmp_nodes = xstrdup("waiting..."); |
| tmp_node_cnt[0] = '\0'; |
| state = JOB_PENDING; |
| } else { |
| secs2time_str(step_ptr->run_time, |
| tmp_time_run, sizeof(tmp_time_run)); |
| tmp_nodes = slurm_sort_node_list_str(step_ptr->nodes); |
| convert_num_unit((float)_nodes_in_list(tmp_nodes), |
| tmp_node_cnt, sizeof(tmp_node_cnt), |
| UNIT_NONE, NO_VAL, |
| working_sview_config.convert_flags); |
| } |
| |
| convert_num_unit((float)step_ptr->num_tasks, tmp_task_cnt, |
| sizeof(tmp_task_cnt), UNIT_NONE, NO_VAL, |
| working_sview_config.convert_flags); |
| |
| if ((step_ptr->time_limit == NO_VAL) || |
| (step_ptr->time_limit == INFINITE)) { |
| sprintf(tmp_time_limit, "Job Limit"); |
| } else { |
| secs2time_str((step_ptr->time_limit * 60), |
| tmp_time_limit, sizeof(tmp_time_limit)); |
| } |
| |
| slurm_make_time_str((time_t *)&step_ptr->start_time, tmp_time_start, |
| sizeof(tmp_time_start)); |
| |
| _stepstr_from_step(step_ptr, tmp_fmt_stepid, sizeof(tmp_fmt_stepid)); |
| snprintf(tmp_step_id, sizeof(tmp_step_id), "%u", |
| step_ptr->step_id.step_id); |
| |
| if (step_ptr->array_job_id) { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u_%u.%u (%u.%u)", |
| step_ptr->array_job_id, step_ptr->array_task_id, |
| step_ptr->step_id.step_id, |
| step_ptr->step_id.job_id, step_ptr->step_id.step_id); |
| // } else if (step_ptr->het_job_id) { |
| // snprintf(tmp_job_id, sizeof(tmp_job_id), "%u+%u.%u (%u.%u)", |
| // step_ptr->het_job_id, step_ptr->het_job_offset, |
| // step_ptr->step_id.step_id, |
| // step_ptr->step_id.job_id, step_ptr->step_id.step_id); |
| } else { |
| snprintf(tmp_job_id, sizeof(tmp_job_id), "%u.%s", |
| step_ptr->step_id.job_id, tmp_fmt_stepid); |
| } |
| |
| tmp_uname = uid_to_string_cached((uid_t)step_ptr->user_id); |
| |
| gtk_tree_store_set(treestore, iter, |
| SORTID_ALLOC, 0, |
| SORTID_COLOR, sview_colors[color_inx], |
| SORTID_COLOR_INX, color_inx, |
| SORTID_CPUS, tmp_cpu_min, |
| SORTID_CPUS_PER_TRES, step_ptr->cpus_per_tres, |
| SORTID_JOBID, tmp_fmt_stepid, |
| SORTID_JOBID_FORMATTED, tmp_job_id, |
| SORTID_MEM_PER_TRES, step_ptr->mem_per_tres, |
| SORTID_NAME, step_ptr->name, |
| SORTID_NODE_INX, step_ptr->node_inx, |
| SORTID_NODELIST, tmp_nodes, |
| SORTID_NODES, tmp_node_cnt, |
| SORTID_PARTITION, step_ptr->partition, |
| SORTID_STATE, job_state_string(state), |
| SORTID_TASKS, tmp_task_cnt, |
| SORTID_TIME_RUNNING, tmp_time_run, |
| SORTID_TIME_START, tmp_time_start, |
| SORTID_TIMELIMIT, tmp_time_limit, |
| SORTID_TRES_ALLOC, step_ptr->tres_fmt_alloc_str, |
| SORTID_TRES_BIND, step_ptr->tres_bind, |
| SORTID_TRES_FREQ, step_ptr->tres_freq, |
| SORTID_TRES_PER_JOB, step_ptr->tres_per_step, |
| SORTID_TRES_PER_NODE, step_ptr->tres_per_node, |
| SORTID_TRES_PER_SOCKET, step_ptr->tres_per_socket, |
| SORTID_TRES_PER_TASK, step_ptr->tres_per_task, |
| SORTID_UPDATED, 1, |
| SORTID_USER_ID, tmp_uname, |
| -1); |
| |
| xfree(tmp_nodes); |
| |
| return; |
| } |
| |
| static void _append_job_record(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeStore *treestore) |
| { |
| gtk_tree_store_append(treestore, &sview_job_info_ptr->iter_ptr, NULL); |
| gtk_tree_store_set(treestore, &sview_job_info_ptr->iter_ptr, SORTID_POS, |
| sview_job_info_ptr->pos, -1); |
| _update_job_record(sview_job_info_ptr, treestore, NULL, true, false); |
| } |
| |
| static void _append_task_record(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeStore *treestore, GtkTreeIter *iter, |
| bool handle_pending) |
| { |
| GtkTreeIter task_iter; |
| |
| gtk_tree_store_append(treestore, &task_iter, iter); |
| gtk_tree_store_set(treestore, &task_iter, SORTID_POS, |
| sview_job_info_ptr->pos, -1); |
| _update_job_record(sview_job_info_ptr, treestore, &task_iter, false, |
| handle_pending); |
| } |
| |
| |
| static void _append_step_record(job_step_info_t *step_ptr, |
| GtkTreeStore *treestore, GtkTreeIter *iter, |
| int jobid, bool suspended) |
| { |
| GtkTreeIter step_iter; |
| |
| gtk_tree_store_append(treestore, &step_iter, iter); |
| gtk_tree_store_set(treestore, &step_iter, SORTID_POS, jobid, -1); |
| _update_step_record(step_ptr, treestore, &step_iter, suspended); |
| } |
| |
| static void _handle_task_check(sview_job_info_t *task_ptr, |
| GtkTreeModel *model, |
| GtkTreeIter **task_iter, |
| GtkTreeIter *first_task_iter, |
| GtkTreeIter *iter, |
| bool handle_pending) |
| { |
| /* get the iter, or find out the list is empty goto add */ |
| if (!*task_iter) |
| goto adding; |
| else |
| memcpy(*task_iter, first_task_iter, sizeof(GtkTreeIter)); |
| |
| while (1) { |
| char *tmp_taskid, *use_id; |
| /* search for the jobid and check to see if |
| * it is in the list */ |
| gtk_tree_model_get(model, *task_iter, SORTID_JOBID, |
| &tmp_taskid, -1); |
| |
| if (handle_pending) |
| use_id = task_ptr->task_pending_hl_str; |
| else |
| use_id = task_ptr->job_id_str; |
| |
| if (tmp_taskid && use_id && !xstrcmp(tmp_taskid, use_id)) { |
| /* update with new info */ |
| _update_job_record(task_ptr, |
| GTK_TREE_STORE(model), |
| *task_iter, false, handle_pending); |
| g_free(tmp_taskid); |
| goto found; |
| } |
| g_free(tmp_taskid); |
| |
| if (!gtk_tree_model_iter_next(model, *task_iter)) { |
| *task_iter = NULL; |
| break; |
| } |
| } |
| adding: |
| _append_task_record(task_ptr, GTK_TREE_STORE(model), |
| iter, handle_pending); |
| found: |
| return; |
| |
| |
| } |
| |
| |
| static void _update_info_task(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeModel *model, |
| GtkTreeIter *task_iter, |
| GtkTreeIter *iter, bool handle_pending) |
| { |
| int i; |
| GtkTreeIter first_task_iter; |
| int set = 0; |
| list_itr_t *itr = NULL; |
| sview_job_info_t *task_ptr = NULL; |
| |
| memset(&first_task_iter, 0, sizeof(GtkTreeIter)); |
| |
| /* make sure all the tasks are still here */ |
| if (task_iter) { |
| first_task_iter = *task_iter; |
| while (1) { |
| gtk_tree_store_set(GTK_TREE_STORE(model), task_iter, |
| SORTID_UPDATED, 0, -1); |
| if (!gtk_tree_model_iter_next(model, task_iter)) { |
| break; |
| } |
| } |
| memcpy(task_iter, &first_task_iter, sizeof(GtkTreeIter)); |
| set = 1; |
| } |
| if (handle_pending) |
| itr = list_iterator_create( |
| sview_job_info_ptr->task_pending_list); |
| else { |
| /* First handle the pending list if one exists. This |
| will make a dummy job record that holds all the |
| pending jobs. |
| */ |
| if (sview_job_info_ptr->task_pending_list && |
| list_count(sview_job_info_ptr->task_pending_list)) |
| _handle_task_check(sview_job_info_ptr, model, |
| &task_iter, &first_task_iter, |
| iter, true); |
| itr = list_iterator_create(sview_job_info_ptr->task_list); |
| } |
| while ((task_ptr = list_next(itr))) |
| _handle_task_check(task_ptr, model, &task_iter, |
| &first_task_iter, iter, false); |
| list_iterator_destroy(itr); |
| |
| if (set) { |
| task_iter = &first_task_iter; |
| /* clear all tasks that aren't active */ |
| while (1) { |
| gtk_tree_model_get(model, task_iter, |
| SORTID_UPDATED, &i, -1); |
| if (!i) { |
| if (!gtk_tree_store_remove( |
| GTK_TREE_STORE(model), |
| task_iter)) |
| break; |
| else |
| continue; |
| } |
| if (!gtk_tree_model_iter_next(model, task_iter)) { |
| break; |
| } |
| } |
| } |
| return; |
| } |
| |
| static void _update_info_step(sview_job_info_t *sview_job_info_ptr, |
| GtkTreeModel *model, |
| GtkTreeIter *step_iter, |
| GtkTreeIter *iter) |
| { |
| int stepid = 0; |
| int i; |
| GtkTreeIter first_step_iter; |
| int set = 0; |
| list_itr_t *itr = NULL; |
| job_step_info_t *step_ptr = NULL; |
| |
| memset(&first_step_iter, 0, sizeof(GtkTreeIter)); |
| |
| /* make sure all the steps are still here */ |
| if (step_iter) { |
| first_step_iter = *step_iter; |
| while (1) { |
| gtk_tree_store_set(GTK_TREE_STORE(model), step_iter, |
| SORTID_UPDATED, 0, -1); |
| if (!gtk_tree_model_iter_next(model, step_iter)) { |
| break; |
| } |
| } |
| memcpy(step_iter, &first_step_iter, sizeof(GtkTreeIter)); |
| set = 1; |
| } |
| itr = list_iterator_create(sview_job_info_ptr->step_list); |
| while ((step_ptr = list_next(itr))) { |
| /* get the iter, or find out the list is empty goto add */ |
| if (!step_iter) { |
| goto adding; |
| } else { |
| memcpy(step_iter, &first_step_iter, |
| sizeof(GtkTreeIter)); |
| } |
| while (1) { |
| char *tmp_stepid; |
| /* search for the jobid and check to see if |
| * it is in the list */ |
| gtk_tree_model_get(model, step_iter, SORTID_JOBID, |
| &tmp_stepid, -1); |
| stepid = atoi(tmp_stepid); |
| g_free(tmp_stepid); |
| if (stepid == (int)step_ptr->step_id.step_id) { |
| /* update with new info */ |
| _update_step_record( |
| step_ptr, GTK_TREE_STORE(model), |
| step_iter, IS_JOB_SUSPENDED( |
| sview_job_info_ptr->job_ptr)); |
| goto found; |
| } |
| |
| if (!gtk_tree_model_iter_next(model, step_iter)) { |
| step_iter = NULL; |
| break; |
| } |
| } |
| adding: |
| _append_step_record(step_ptr, GTK_TREE_STORE(model), |
| iter, sview_job_info_ptr->job_ptr->job_id, |
| IS_JOB_SUSPENDED( |
| sview_job_info_ptr->job_ptr)); |
| found: |
| ; |
| } |
| list_iterator_destroy(itr); |
| |
| if (set) { |
| step_iter = &first_step_iter; |
| /* clear all steps that aren't active */ |
| while (1) { |
| gtk_tree_model_get(model, step_iter, |
| SORTID_UPDATED, &i, -1); |
| if (!i) { |
| if (!gtk_tree_store_remove( |
| GTK_TREE_STORE(model), |
| step_iter)) |
| break; |
| else |
| continue; |
| } |
| if (!gtk_tree_model_iter_next(model, step_iter)) { |
| break; |
| } |
| } |
| } |
| return; |
| } |
| |
| static void _update_info_job(list_t *info_list, GtkTreeView *tree_view) |
| { |
| GtkTreeModel *model = gtk_tree_view_get_model(tree_view); |
| int jobid = 0; |
| job_info_t *job_ptr = NULL; |
| list_itr_t *itr = NULL; |
| sview_job_info_t *sview_job_info = NULL; |
| |
| set_for_update(model, SORTID_UPDATED); |
| |
| itr = list_iterator_create(info_list); |
| while ((sview_job_info = list_next(itr))) { |
| job_ptr = sview_job_info->job_ptr; |
| |
| /* This means the tree_store changed (added new column |
| * or something). */ |
| if (last_model != model) |
| sview_job_info->iter_set = false; |
| |
| if (sview_job_info->iter_set) { |
| char *tmp_jobid = NULL, *offset = NULL; |
| gtk_tree_model_get(model, &sview_job_info->iter_ptr, |
| SORTID_JOBID, &tmp_jobid, -1); |
| if (!tmp_jobid) |
| continue; |
| |
| offset = strchr(tmp_jobid, '('); |
| if (offset) |
| offset++; |
| else |
| offset = tmp_jobid; |
| jobid = atoi(offset); |
| g_free(tmp_jobid); |
| |
| if ((jobid != job_ptr->job_id) |
| && (jobid != job_ptr->array_job_id) && |
| (jobid != job_ptr->het_job_id)) { |
| /* Bad pointer */ |
| sview_job_info->iter_set = false; |
| } |
| } |
| if (sview_job_info->iter_set) |
| _update_job_record(sview_job_info, |
| GTK_TREE_STORE(model), NULL, true, |
| false); |
| else { |
| _append_job_record(sview_job_info, |
| GTK_TREE_STORE(model)); |
| sview_job_info->iter_set = true; |
| } |
| } |
| list_iterator_destroy(itr); |
| |
| /* remove all old jobs */ |
| remove_old(model, SORTID_UPDATED); |
| last_model = model; |
| return; |
| } |
| |
| static int _sview_job_sort_aval_dec(void *s1, void *s2) |
| { |
| sview_job_info_t* rec_a = *(sview_job_info_t **)s1; |
| sview_job_info_t* rec_b = *(sview_job_info_t **)s2; |
| int size_a; |
| int size_b; |
| |
| size_a = rec_a->node_cnt; |
| size_b = rec_b->node_cnt; |
| |
| if (size_a < size_b) |
| return -1; |
| else if (size_a > size_b) |
| return 1; |
| |
| if (rec_a->nodes && rec_b->nodes) { |
| size_a = xstrcmp(rec_a->nodes, rec_b->nodes); |
| if (size_a < 0) |
| return -1; |
| else if (size_a > 0) |
| return 1; |
| } |
| return 0; |
| } |
| |
| static int _task_array_match(void *x, void *key) |
| { |
| sview_job_info_t *sview_job_info_ptr = (sview_job_info_t *) x; |
| job_info_t *job_ptr = (job_info_t *) key; |
| |
| if (sview_job_info_ptr->job_ptr->array_job_id == job_ptr->array_job_id) |
| return 1; |
| |
| return 0; |
| } |
| |
| static int _het_job_id_match(void *x, void *key) |
| { |
| sview_job_info_t *sview_job_info_ptr = (sview_job_info_t *) x; |
| job_info_t *job_ptr = (job_info_t *) key; |
| |
| if (sview_job_info_ptr->job_ptr->het_job_id == job_ptr->het_job_id) |
| return 1; |
| |
| return 0; |
| } |
| |
| static list_t *_create_job_info_list(job_info_msg_t *job_info_ptr, |
| job_step_info_response_msg_t *step_info_ptr, |
| int want_odd_states) |
| { |
| static list_t *info_list = NULL; |
| static list_t *odd_info_list = NULL; |
| list_t *last_list = NULL; |
| list_itr_t *last_list_itr = NULL; |
| static job_info_msg_t *last_job_info_ptr = NULL; |
| static job_step_info_response_msg_t *last_step_info_ptr = NULL; |
| int i = 0, j = 0; |
| sview_job_info_t *sview_job_info_ptr = NULL; |
| job_info_t *job_ptr = NULL; |
| job_step_info_t *step_ptr = NULL; |
| |
| if (info_list && (job_info_ptr == last_job_info_ptr) |
| && (step_info_ptr == last_step_info_ptr)) |
| goto update_color; |
| |
| last_job_info_ptr = job_info_ptr; |
| last_step_info_ptr = step_info_ptr; |
| |
| if (info_list) { |
| list_flush(info_list); |
| last_list = odd_info_list; |
| odd_info_list = list_create(_job_info_list_del); |
| } else { |
| info_list = list_create(NULL); |
| odd_info_list = list_create(_job_info_list_del); |
| } |
| if (last_list) |
| last_list_itr = list_iterator_create(last_list); |
| for (i=0; i<job_info_ptr->record_count; i++) { |
| bool added_task = false; |
| |
| job_ptr = &(job_info_ptr->job_array[i]); |
| if (job_ptr->job_id == 0) |
| continue; |
| |
| sview_job_info_ptr = NULL; |
| |
| if (last_list_itr) { |
| while ((sview_job_info_ptr = |
| list_next(last_list_itr))) { |
| if (sview_job_info_ptr->job_id == |
| job_ptr->job_id) { |
| list_remove(last_list_itr); |
| _job_info_free(sview_job_info_ptr); |
| break; |
| } |
| } |
| list_iterator_reset(last_list_itr); |
| } |
| |
| if (!sview_job_info_ptr) |
| sview_job_info_ptr = xmalloc(sizeof(sview_job_info_t)); |
| |
| sview_job_info_ptr->job_ptr = job_ptr; |
| sview_job_info_ptr->job_id = job_ptr->job_id; |
| |
| if (job_ptr->array_task_str || |
| (job_ptr->array_task_id != NO_VAL)) { |
| char task_str[64]; |
| sview_job_info_t *first_job_info_ptr = |
| list_find_first(info_list, |
| _task_array_match, job_ptr); |
| if (job_ptr->array_task_str) { |
| snprintf(task_str, sizeof(task_str), "[%s]", |
| job_ptr->array_task_str); |
| } else { |
| snprintf(task_str, sizeof(task_str), "%u", |
| job_ptr->array_task_id); |
| } |
| |
| if (!first_job_info_ptr) { |
| sview_job_info_ptr->task_list = |
| list_create(NULL); |
| sview_job_info_ptr->task_hl = |
| hostlist_create(NULL); |
| first_job_info_ptr = sview_job_info_ptr; |
| } else if (!IS_JOB_COMPLETED(job_ptr)) |
| added_task = true; |
| |
| hostlist_push_host(first_job_info_ptr->task_hl, |
| task_str); |
| |
| if (IS_JOB_PENDING(job_ptr)) { |
| if (!first_job_info_ptr->task_pending_list) |
| first_job_info_ptr->task_pending_list = |
| list_create(NULL); |
| if (!first_job_info_ptr->task_pending_hl) |
| first_job_info_ptr->task_pending_hl = |
| hostlist_create(NULL); |
| hostlist_push_host( |
| first_job_info_ptr->task_pending_hl, |
| task_str); |
| list_append(first_job_info_ptr-> |
| task_pending_list, |
| sview_job_info_ptr); |
| } else if (!IS_JOB_COMPLETED(job_ptr)) |
| list_append(first_job_info_ptr->task_list, |
| sview_job_info_ptr); |
| if (job_ptr->array_task_str) { |
| sview_job_info_ptr->job_id_str = |
| xstrdup_printf("%u_[%s] (%u)", |
| job_ptr->array_job_id, |
| job_ptr->array_task_str, |
| job_ptr->job_id); |
| } else { |
| sview_job_info_ptr->job_id_str = |
| xstrdup_printf("%u_%u (%u)", |
| job_ptr->array_job_id, |
| job_ptr->array_task_id, |
| job_ptr->job_id); |
| } |
| } else if (job_ptr->het_job_id) { |
| char comp_str[64]; |
| snprintf(comp_str, sizeof(comp_str), "%u", |
| job_ptr->het_job_offset); |
| sview_job_info_t *first_job_info_ptr = |
| list_find_first(info_list, |
| _het_job_id_match, job_ptr); |
| if (!first_job_info_ptr) { |
| sview_job_info_ptr->task_list = |
| list_create(NULL); |
| sview_job_info_ptr->task_hl = |
| hostlist_create(NULL); |
| first_job_info_ptr = sview_job_info_ptr; |
| } else if (!IS_JOB_COMPLETED(job_ptr)) |
| added_task = true; |
| |
| hostlist_push_host(first_job_info_ptr->task_hl, |
| comp_str); |
| if (!IS_JOB_COMPLETED(job_ptr)) |
| list_append(first_job_info_ptr->task_list, |
| sview_job_info_ptr); |
| sview_job_info_ptr->job_id_str = |
| xstrdup_printf("%u+%u (%u)", |
| job_ptr->het_job_id, |
| job_ptr->het_job_offset, |
| job_ptr->job_id); |
| } else |
| sview_job_info_ptr->job_id_str = |
| xstrdup_printf("%u", job_ptr->job_id); |
| |
| sview_job_info_ptr->step_list = list_create(NULL); |
| sview_job_info_ptr->pos = i; |
| sview_job_info_ptr->node_cnt = 0; |
| sview_job_info_ptr->color_inx = |
| job_ptr->job_id % sview_colors_cnt; |
| sview_job_info_ptr->nodes = xstrdup(job_ptr->nodes); |
| sview_job_info_ptr->node_cnt = job_ptr->num_nodes; |
| |
| for (j = 0; j < step_info_ptr->job_step_count; j++) { |
| step_ptr = &(step_info_ptr->job_steps[j]); |
| if ((step_ptr->step_id.job_id == job_ptr->job_id) && |
| (step_ptr->state == JOB_RUNNING)) { |
| list_append(sview_job_info_ptr->step_list, |
| step_ptr); |
| } |
| } |
| if (!added_task) |
| list_append(odd_info_list, sview_job_info_ptr); |
| |
| if (!IS_JOB_PENDING(job_ptr) && |
| !IS_JOB_RUNNING(job_ptr) && |
| !IS_JOB_SUSPENDED(job_ptr) && |
| !IS_JOB_COMPLETING(job_ptr)) { |
| continue; |
| } |
| |
| if (!added_task) |
| list_append(info_list, sview_job_info_ptr); |
| } |
| |
| list_sort(info_list, (ListCmpF)_sview_job_sort_aval_dec); |
| |
| list_sort(odd_info_list, (ListCmpF)_sview_job_sort_aval_dec); |
| |
| if (last_list) { |
| list_iterator_destroy(last_list_itr); |
| FREE_NULL_LIST(last_list); |
| } |
| |
| update_color: |
| |
| if (want_odd_states) |
| return odd_info_list; |
| else |
| return info_list; |
| |
| } |
| |
| void _display_info_job(list_t *info_list, popup_info_t *popup_win) |
| { |
| job_step_info_t *step_ptr; |
| specific_info_t *spec_info = popup_win->spec_info; |
| list_itr_t *itr = NULL, *itr2 = NULL; |
| sview_job_info_t *sview_job_info = NULL, *sview_job_info2 = NULL; |
| int found = 0; |
| GtkTreeView *treeview = NULL; |
| int update = 0; |
| int j, k; |
| |
| if (spec_info->search_info->int_data == NO_VAL) { |
| /* info = xstrdup("No pointer given!"); */ |
| goto finished; |
| } |
| |
| need_refresh: |
| if (!spec_info->display_widget) { |
| treeview = create_treeview_2cols_attach_to_table( |
| popup_win->table); |
| spec_info->display_widget = |
| g_object_ref(GTK_WIDGET(treeview)); |
| } else { |
| treeview = GTK_TREE_VIEW(spec_info->display_widget); |
| update = 1; |
| } |
| |
| itr = list_iterator_create(info_list); |
| while ((sview_job_info = list_next(itr))) { |
| if (sview_job_info->job_ptr->job_id == |
| spec_info->search_info->int_data) |
| break; |
| if (sview_job_info->task_list) { |
| itr2 = list_iterator_create(sview_job_info->task_list); |
| while ((sview_job_info2 = list_next(itr2))) { |
| if (sview_job_info2->job_ptr->job_id == |
| spec_info->search_info->int_data) |
| break; |
| } |
| list_iterator_destroy(itr2); |
| if (sview_job_info2) { |
| sview_job_info = sview_job_info2; |
| break; |
| } |
| } |
| if (sview_job_info->task_pending_list) { |
| itr2 = list_iterator_create( |
| sview_job_info->task_pending_list); |
| while ((sview_job_info2 = list_next(itr2))) { |
| if (sview_job_info2->job_ptr->job_id == |
| spec_info->search_info->int_data) |
| break; |
| } |
| list_iterator_destroy(itr2); |
| if (sview_job_info2) { |
| sview_job_info = sview_job_info2; |
| break; |
| } |
| } |
| } |
| list_iterator_destroy(itr); |
| |
| if (!sview_job_info) { |
| /* not found */ |
| } else if (spec_info->search_info->int_data2 == NO_VAL) { |
| int top_node_inx = 0; |
| int array_size = SVIEW_MAX_NODE_SPACE; |
| int *color_inx = xmalloc(sizeof(int) * array_size); |
| bool *color_set_flag = xmalloc(sizeof(bool) * array_size); |
| j = 0; |
| while (sview_job_info->job_ptr->node_inx[j] >= 0) { |
| top_node_inx = MAX(top_node_inx, |
| sview_job_info->job_ptr-> |
| node_inx[j+1]); |
| if (top_node_inx > SVIEW_MAX_NODE_SPACE) |
| fatal("Expand SVIEW_MAX_NODE_SPACE in sview"); |
| for (k = sview_job_info->job_ptr->node_inx[j]; |
| k <= sview_job_info->job_ptr->node_inx[j+1]; |
| k++) { |
| color_set_flag[k] = true; |
| color_inx[k] = sview_job_info-> |
| color_inx; |
| } |
| j += 2; |
| } |
| change_grid_color_array(popup_win->grid_button_list, |
| top_node_inx+1, color_inx, |
| color_set_flag, true, 0); |
| xfree(color_inx); |
| xfree(color_set_flag); |
| _layout_job_record(treeview, sview_job_info, update); |
| found = 1; |
| } else { |
| int top_node_inx = 0; |
| int array_size = SVIEW_MAX_NODE_SPACE; |
| int *color_inx = xmalloc(sizeof(int) * array_size); |
| bool *color_set_flag = xmalloc(sizeof(bool) * array_size); |
| itr = list_iterator_create(sview_job_info->step_list); |
| while ((step_ptr = list_next(itr))) { |
| if (step_ptr->step_id.step_id == |
| spec_info->search_info->int_data2) { |
| j = 0; |
| while (step_ptr->node_inx[j] >= 0) { |
| top_node_inx = MAX(top_node_inx, |
| step_ptr-> |
| node_inx[j+1]); |
| if (top_node_inx > SVIEW_MAX_NODE_SPACE) |
| fatal("Expand " |
| "SVIEW_MAX_NODE_SPACE " |
| "in sview"); |
| for (k = step_ptr->node_inx[j]; |
| k <= step_ptr->node_inx[j+1]; |
| k++) { |
| color_set_flag[k] = true; |
| color_inx[k] = step_ptr->step_id.step_id |
| % sview_colors_cnt; |
| } |
| j += 2; |
| } |
| change_grid_color_array( |
| popup_win->grid_button_list, |
| top_node_inx+1, color_inx, |
| color_set_flag, false, 0); |
| xfree(color_inx); |
| xfree(color_set_flag); |
| |
| _layout_step_record( |
| treeview, step_ptr, update, |
| IS_JOB_SUSPENDED( |
| sview_job_info->job_ptr)); |
| found = 1; |
| break; |
| } |
| } |
| list_iterator_destroy(itr); |
| xfree(color_inx); |
| xfree(color_set_flag); |
| } |
| post_setup_popup_grid_list(popup_win); |
| |
| if (!found) { |
| if (!popup_win->not_found) { |
| char *temp = "JOB ALREADY FINISHED OR NOT FOUND\n"; |
| GtkTreeIter iter; |
| GtkTreeModel *model = NULL; |
| |
| /* only time this will be run so no update */ |
| model = gtk_tree_view_get_model(treeview); |
| add_display_treestore_line(0, |
| GTK_TREE_STORE(model), |
| &iter, |
| temp, ""); |
| if (spec_info->search_info->int_data2 != NO_VAL) |
| add_display_treestore_line( |
| 1, |
| GTK_TREE_STORE(model), |
| &iter, |
| find_col_name(display_data_job, |
| SORTID_STATE), |
| job_state_string(JOB_COMPLETE)); |
| } |
| popup_win->not_found = true; |
| } else { |
| if (popup_win->not_found) { |
| popup_win->not_found = false; |
| gtk_widget_destroy(spec_info->display_widget); |
| |
| goto need_refresh; |
| } |
| } |
| gtk_widget_show_all(spec_info->display_widget); |
| |
| finished: |
| return; |
| } |
| |
| extern void refresh_job(GtkAction *action, gpointer user_data) |
| { |
| popup_info_t *popup_win = (popup_info_t *)user_data; |
| xassert(popup_win); |
| xassert(popup_win->spec_info); |
| xassert(popup_win->spec_info->title); |
| popup_win->force_refresh = 1; |
| specific_info_job(popup_win); |
| } |
| |
| extern int get_new_info_job(job_info_msg_t **info_ptr, |
| int force) |
| { |
| job_info_msg_t *new_job_ptr = NULL; |
| uint16_t show_flags = 0; |
| int error_code = SLURM_NO_CHANGE_IN_DATA, i; |
| time_t now = time(NULL); |
| static time_t last; |
| static bool changed = 0; |
| static uint16_t last_flags = 0; |
| slurm_job_info_t *job_ptr; |
| char *local_cluster; |
| |
| if (g_job_info_ptr && !force |
| && ((now - last) < working_sview_config.refresh_delay)) { |
| if (*info_ptr != g_job_info_ptr) |
| error_code = SLURM_SUCCESS; |
| *info_ptr = g_job_info_ptr; |
| if (changed) |
| error_code = SLURM_SUCCESS; |
| goto end_it; |
| } |
| last = now; |
| |
| if (cluster_flags & CLUSTER_FLAG_FED) |
| show_flags |= SHOW_FEDERATION; |
| if (working_sview_config.show_hidden) |
| show_flags |= SHOW_ALL; |
| if (g_job_info_ptr) { |
| if (show_flags != last_flags) |
| g_job_info_ptr->last_update = 0; |
| error_code = slurm_load_jobs(g_job_info_ptr->last_update, |
| &new_job_ptr, show_flags); |
| if (error_code == SLURM_SUCCESS) { |
| slurm_free_job_info_msg(g_job_info_ptr); |
| changed = 1; |
| } else if (errno == SLURM_NO_CHANGE_IN_DATA) { |
| error_code = SLURM_NO_CHANGE_IN_DATA; |
| new_job_ptr = g_job_info_ptr; |
| changed = 0; |
| } |
| } else { |
| new_job_ptr = NULL; |
| error_code = slurm_load_jobs((time_t) NULL, &new_job_ptr, |
| show_flags); |
| changed = 1; |
| } |
| |
| /* If job not local, clear node_inx to avoid setting node colors */ |
| if (working_cluster_rec && working_cluster_rec->name) |
| local_cluster = xstrdup(working_cluster_rec->name); |
| else |
| local_cluster = xstrdup(slurm_conf.cluster_name); |
| if (error_code == SLURM_SUCCESS) { |
| for (i = 0, job_ptr = new_job_ptr->job_array; |
| i < new_job_ptr->record_count; i++, job_ptr++) { |
| if (job_ptr->node_inx && job_ptr->cluster && |
| xstrcmp(job_ptr->cluster, local_cluster)) { |
| job_ptr->node_inx[0] = -1; |
| } |
| } |
| } |
| xfree(local_cluster); |
| |
| last_flags = show_flags; |
| g_job_info_ptr = new_job_ptr; |
| |
| if (g_job_info_ptr && (*info_ptr != g_job_info_ptr)) |
| error_code = SLURM_SUCCESS; |
| |
| *info_ptr = g_job_info_ptr; |
| end_it: |
| return error_code; |
| } |
| |
| extern int get_new_info_job_step(job_step_info_response_msg_t **info_ptr, |
| int force) |
| { |
| job_step_info_response_msg_t *new_step_ptr = NULL; |
| uint16_t show_flags = 0; |
| int error_code = SLURM_NO_CHANGE_IN_DATA; |
| time_t now = time(NULL); |
| static time_t last; |
| static bool changed = 0; |
| |
| if (g_step_info_ptr && !force |
| && ((now - last) < working_sview_config.refresh_delay)) { |
| if (*info_ptr != g_step_info_ptr) |
| error_code = SLURM_SUCCESS; |
| *info_ptr = g_step_info_ptr; |
| if (changed) |
| error_code = SLURM_SUCCESS; |
| goto end_it; |
| } |
| last = now; |
| |
| /* This needs to always be like this even if you are only |
| looking for non-hidden jobs or you will get an error below. |
| */ |
| show_flags |= SHOW_ALL; |
| if (g_step_info_ptr) { |
| /* Use a last_update time of NULL so that we can get an updated |
| * run_time for jobs rather than just its start_time */ |
| error_code = slurm_get_job_steps((time_t) NULL, |
| NO_VAL, NO_VAL, &new_step_ptr, |
| show_flags); |
| if (error_code == SLURM_SUCCESS) { |
| slurm_free_job_step_info_response_msg(g_step_info_ptr); |
| changed = 1; |
| } else if (errno == SLURM_NO_CHANGE_IN_DATA) { |
| error_code = SLURM_NO_CHANGE_IN_DATA; |
| new_step_ptr = g_step_info_ptr; |
| changed = 0; |
| } |
| } else { |
| new_step_ptr = NULL; |
| error_code = slurm_get_job_steps((time_t) NULL, NO_VAL, NO_VAL, |
| &new_step_ptr, show_flags); |
| changed = 1; |
| } |
| |
| g_step_info_ptr = new_step_ptr; |
| |
| if (g_step_info_ptr && (*info_ptr != g_step_info_ptr)) |
| error_code = SLURM_SUCCESS; |
| |
| *info_ptr = g_step_info_ptr; |
| end_it: |
| return error_code; |
| } |
| |
| extern GtkListStore *create_model_job(int type) |
| { |
| GtkListStore *model = NULL; |
| GtkTreeIter iter; |
| |
| last_model = NULL; /* Reformat display */ |
| switch(type) { |
| case SORTID_ACTION: |
| model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 1, SORTID_ACTION, |
| 0, "None", |
| -1); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 1, SORTID_ACTION, |
| 0, "Cancel", |
| -1); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 1, SORTID_ACTION, |
| 0, "Suspend/Resume", |
| -1); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 1, SORTID_ACTION, |
| 0, "Requeue", |
| -1); |
| break; |
| case SORTID_CONTIGUOUS: |
| case SORTID_REBOOT: |
| case SORTID_REQUEUE: |
| case SORTID_OVER_SUBSCRIBE: |
| model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 0, "yes", |
| 1, type, |
| -1); |
| gtk_list_store_append(model, &iter); |
| gtk_list_store_set(model, &iter, |
| 0, "no", |
| 1, type, |
| -1); |
| break; |
| default: |
| break; |
| } |
| |
| return model; |
| } |
| |
| extern void admin_edit_job(GtkCellRendererText *cell, |
| const char *path_string, |
| const char *new_text, |
| gpointer data) |
| { |
| GtkTreeStore *treestore = GTK_TREE_STORE(data); |
| GtkTreePath *path = gtk_tree_path_new_from_string(path_string); |
| GtkTreeIter iter; |
| job_desc_msg_t *job_msg = xmalloc(sizeof(job_desc_msg_t)); |
| char *tmp_jobid = NULL, *offset; |
| |
| char *temp = NULL; |
| char *old_text = NULL; |
| const char *type = NULL; |
| int stepid = NO_VAL; |
| int column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), |
| "column")); |
| |
| if (!new_text || !xstrcmp(new_text, "")) |
| goto no_input; |
| |
| gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), &iter, path); |
| |
| slurm_init_job_desc_msg(job_msg); |
| gtk_tree_model_get(GTK_TREE_MODEL(treestore), &iter, |
| SORTID_JOBID, &tmp_jobid, |
| column, &old_text, |
| -1); |
| if (!tmp_jobid) |
| goto no_input; |
| |
| offset = strchr(tmp_jobid, '('); |
| if (offset) |
| offset++; |
| else |
| offset = tmp_jobid; |
| job_msg->job_id = atoi(offset); |
| g_free(tmp_jobid); |
| |
| gtk_tree_model_get(GTK_TREE_MODEL(treestore), &iter, |
| SORTID_ALLOC, &stepid, -1); |
| if (stepid) |
| stepid = NO_VAL; |
| else { |
| stepid = job_msg->job_id; |
| gtk_tree_model_get(GTK_TREE_MODEL(treestore), &iter, |
| SORTID_POS, &job_msg->job_id, -1); |
| } |
| |
| type = _set_job_msg(job_msg, new_text, column); |
| if (global_edit_error) |
| goto print_error; |
| |
| if (got_edit_signal) { |
| temp = got_edit_signal; |
| got_edit_signal = NULL; |
| admin_job(GTK_TREE_MODEL(treestore), &iter, temp, NULL); |
| xfree(temp); |
| goto no_input; |
| } |
| |
| if (old_text && !xstrcmp(old_text, new_text)) { |
| temp = g_strdup_printf("No change in value."); |
| } else if (slurm_update_job(job_msg) |
| == SLURM_SUCCESS) { |
| gtk_tree_store_set(treestore, &iter, column, new_text, -1); |
| temp = g_strdup_printf("Job %d %s changed to %s", |
| job_msg->job_id, |
| type, |
| new_text); |
| } else if (errno == ESLURM_DISABLED) { |
| temp = g_strdup_printf( |
| "Can only edit %s on pending jobs.", type); |
| } else { |
| print_error: |
| temp = g_strdup_printf("Job %d %s can't be " |
| "set to %s", |
| job_msg->job_id, |
| type, |
| new_text); |
| } |
| |
| display_edit_note(temp); |
| g_free(temp); |
| |
| no_input: |
| slurm_free_job_desc_msg(job_msg); |
| |
| gtk_tree_path_free (path); |
| g_free(old_text); |
| g_mutex_unlock(sview_mutex); |
| } |
| |
| extern void get_info_job(GtkTable *table, display_data_t *display_data) |
| { |
| int job_error_code = SLURM_SUCCESS; |
| int step_error_code = SLURM_SUCCESS; |
| static int view = -1; |
| static job_info_msg_t *job_info_ptr = NULL; |
| static job_step_info_response_msg_t *step_info_ptr = NULL; |
| char error_char[100]; |
| GtkWidget *label = NULL; |
| GtkTreeView *tree_view = NULL; |
| static GtkWidget *display_widget = NULL; |
| list_t *info_list = NULL; |
| int j, k; |
| sview_job_info_t *sview_job_info_ptr = NULL; |
| job_info_t *job_ptr = NULL; |
| list_itr_t *itr = NULL; |
| GtkTreePath *path = NULL; |
| static bool set_opts = false; |
| |
| if (!set_opts) |
| set_page_opts(JOB_PAGE, display_data_job, |
| SORTID_CNT, _initial_page_opts); |
| set_opts = true; |
| |
| /* reset */ |
| if (!table && !display_data) { |
| if (display_widget) |
| gtk_widget_destroy(display_widget); |
| display_widget = NULL; |
| job_info_ptr = NULL; |
| step_info_ptr = NULL; |
| return; |
| } |
| |
| if (display_data) |
| local_display_data = display_data; |
| if (!table) { |
| display_data_job->set_menu = local_display_data->set_menu; |
| return; |
| } |
| if (display_widget && toggled) { |
| gtk_widget_destroy(display_widget); |
| display_widget = NULL; |
| goto display_it; |
| } |
| |
| if ((job_error_code = get_new_info_job(&job_info_ptr, force_refresh)) |
| == SLURM_NO_CHANGE_IN_DATA){ |
| |
| } else if (job_error_code != SLURM_SUCCESS) { |
| if (view == ERROR_VIEW) |
| goto end_it; |
| if (display_widget) |
| gtk_widget_destroy(display_widget); |
| view = ERROR_VIEW; |
| sprintf(error_char, "slurm_load_jobs: %s", |
| slurm_strerror(errno)); |
| label = gtk_label_new(error_char); |
| gtk_table_attach_defaults(table, label, 0, 1, 0, 1); |
| gtk_widget_show(label); |
| display_widget = g_object_ref(GTK_WIDGET(label)); |
| goto end_it; |
| } |
| |
| if ((step_error_code = get_new_info_job_step(&step_info_ptr, |
| force_refresh)) |
| == SLURM_NO_CHANGE_IN_DATA){ |
| if ((!display_widget || view == ERROR_VIEW) |
| || (step_error_code != SLURM_NO_CHANGE_IN_DATA)) |
| goto display_it; |
| } else if (step_error_code != SLURM_SUCCESS) { |
| if (view == ERROR_VIEW) |
| goto end_it; |
| if (display_widget) |
| gtk_widget_destroy(display_widget); |
| view = ERROR_VIEW; |
| sprintf(error_char, "slurm_load_job_step: %s", |
| slurm_strerror(errno)); |
| label = gtk_label_new(error_char); |
| gtk_table_attach_defaults(table, label, 0, 1, 0, 1); |
| gtk_widget_show(label); |
| display_widget = g_object_ref(GTK_WIDGET(label)); |
| goto end_it; |
| } |
| display_it: |
| |
| info_list = _create_job_info_list(job_info_ptr, step_info_ptr, 0); |
| if (!info_list) |
| goto reset_curs; |
| |
| /* set up the grid */ |
| if (display_widget && GTK_IS_TREE_VIEW(display_widget) |
| && gtk_tree_selection_count_selected_rows( |
| gtk_tree_view_get_selection( |
| GTK_TREE_VIEW(display_widget)))) { |
| GtkTreeViewColumn *focus_column = NULL; |
| /* highlight the correct nodes from the last selection */ |
| gtk_tree_view_get_cursor(GTK_TREE_VIEW(display_widget), |
| &path, &focus_column); |
| } |
| if (!path) { |
| int top_node_inx = 0; |
| int array_size = SVIEW_MAX_NODE_SPACE; |
| int *color_inx = xmalloc(sizeof(int) * array_size); |
| bool *color_set_flag = xmalloc(sizeof(bool) * array_size); |
| itr = list_iterator_create(info_list); |
| while ((sview_job_info_ptr = list_next(itr))) { |
| uint32_t base_state; |
| job_ptr = sview_job_info_ptr->job_ptr; |
| base_state = job_ptr->job_state & JOB_STATE_BASE; |
| if (base_state != JOB_RUNNING) |
| continue; |
| j = 0; |
| while (job_ptr->node_inx[j] >= 0) { |
| top_node_inx = MAX(top_node_inx, |
| job_ptr->node_inx[j+1]); |
| if (top_node_inx > SVIEW_MAX_NODE_SPACE) { |
| fatal("Increase SVIEW_MAX_NODE_SPACE " |
| "in sview"); |
| } |
| for (k = job_ptr->node_inx[j]; |
| k <= job_ptr->node_inx[j+1]; k++) { |
| color_set_flag[k] = true; |
| color_inx[k] = sview_job_info_ptr-> |
| color_inx; |
| } |
| j += 2; |
| } |
| } |
| list_iterator_destroy(itr); |
| change_grid_color_array(grid_button_list, top_node_inx+1, |
| color_inx, color_set_flag, true, 0); |
| xfree(color_inx); |
| xfree(color_set_flag); |
| change_grid_color(grid_button_list, -1, -1, |
| MAKE_WHITE, true, 0); |
| } else { |
| highlight_grid(GTK_TREE_VIEW(display_widget), |
| SORTID_NODE_INX, SORTID_COLOR_INX, |
| grid_button_list); |
| gtk_tree_path_free(path); |
| } |
| |
| if (view == ERROR_VIEW && display_widget) { |
| gtk_widget_destroy(display_widget); |
| display_widget = NULL; |
| } |
| if (!display_widget) { |
| tree_view = create_treeview(local_display_data, |
| &grid_button_list); |
| /* set multiple capability here */ |
| gtk_tree_selection_set_mode( |
| gtk_tree_view_get_selection(tree_view), |
| GTK_SELECTION_MULTIPLE); |
| display_widget = g_object_ref(GTK_WIDGET(tree_view)); |
| gtk_table_attach_defaults(GTK_TABLE(table), |
| GTK_WIDGET(tree_view), |
| 0, 1, 0, 1); |
| /* since this function sets the model of the tree_view to the |
| * treestore we don't really care about the return value */ |
| create_treestore(tree_view, display_data_job, |
| SORTID_CNT, SORTID_TIME_SUBMIT, SORTID_COLOR); |
| |
| set_column_width_fixed(tree_view, SORTID_NODELIST, 100); |
| set_column_width_fixed(tree_view, SORTID_NODELIST_EXC, 100); |
| set_column_width_fixed(tree_view, SORTID_NODELIST_REQ, 100); |
| set_column_width_fixed(tree_view, SORTID_NODELIST_SCHED, 100); |
| } |
| |
| view = INFO_VIEW; |
| /* If the system has a large number of jobs then not all lines |
| * will be displayed. You can try different values for the third |
| * argument of gtk_widget_set_size_request() in an attempt to |
| * maximumize the data displayed in your environment. These are my |
| * results: Y=1000 good for 43 lines, Y=-1 good for 1151 lines, |
| * Y=64000 good for 2781 lines, Y=99000 good for 1453 lines */ |
| /* gtk_widget_set_size_request(display_widget, -1, -1); */ |
| _update_info_job(info_list, GTK_TREE_VIEW(display_widget)); |
| end_it: |
| toggled = false; |
| force_refresh = false; |
| |
| reset_curs: |
| if (main_window && main_window->window) |
| gdk_window_set_cursor(main_window->window, NULL); |
| return; |
| } |
| |
| extern void specific_info_job(popup_info_t *popup_win) |
| { |
| int job_error_code = SLURM_SUCCESS; |
| int step_error_code = SLURM_SUCCESS; |
| static job_info_msg_t *job_info_ptr = NULL; |
| static job_step_info_response_msg_t *step_info_ptr = NULL; |
| specific_info_t *spec_info = popup_win->spec_info; |
| sview_search_info_t *search_info = spec_info->search_info; |
| char error_char[100]; |
| GtkWidget *label = NULL; |
| GtkTreeView *tree_view = NULL; |
| list_t *info_list = NULL; |
| list_t *send_info_list = NULL; |
| int j, k; |
| sview_job_info_t *sview_job_info_ptr = NULL; |
| job_info_t *job_ptr = NULL; |
| list_itr_t *itr = NULL; |
| char *uname = NULL; |
| hostset_t *hostset = NULL; |
| int name_diff; |
| int top_node_inx, array_size, *color_inx; |
| bool *color_set_flag; |
| |
| if (!spec_info->display_widget) |
| setup_popup_info(popup_win, display_data_job, SORTID_CNT); |
| |
| if (spec_info->display_widget && popup_win->toggled) { |
| gtk_widget_destroy(spec_info->display_widget); |
| spec_info->display_widget = NULL; |
| goto display_it; |
| } |
| |
| if ((job_error_code = |
| get_new_info_job(&job_info_ptr, popup_win->force_refresh)) |
| == SLURM_NO_CHANGE_IN_DATA) { |
| |
| } else if (job_error_code != SLURM_SUCCESS) { |
| if (spec_info->view == ERROR_VIEW) |
| goto end_it; |
| spec_info->view = ERROR_VIEW; |
| if (spec_info->display_widget) |
| gtk_widget_destroy(spec_info->display_widget); |
| |
| sprintf(error_char, "slurm_load_jobs: %s", |
| slurm_strerror(errno)); |
| label = gtk_label_new(error_char); |
| gtk_table_attach_defaults(GTK_TABLE(popup_win->table), |
| label, |
| 0, 1, 0, 1); |
| gtk_widget_show(label); |
| spec_info->display_widget = g_object_ref(GTK_WIDGET(label)); |
| goto end_it; |
| } |
| |
| if ((step_error_code = |
| get_new_info_job_step(&step_info_ptr, popup_win->force_refresh)) |
| == SLURM_NO_CHANGE_IN_DATA) { |
| if ((!spec_info->display_widget |
| || spec_info->view == ERROR_VIEW) |
| || (step_error_code != SLURM_NO_CHANGE_IN_DATA)) |
| goto display_it; |
| } else if (step_error_code != SLURM_SUCCESS) { |
| if (spec_info->view == ERROR_VIEW) |
| goto end_it; |
| if (spec_info->display_widget) |
| gtk_widget_destroy(spec_info->display_widget); |
| spec_info->view = ERROR_VIEW; |
| sprintf(error_char, "slurm_load_job_step: %s", |
| slurm_strerror(errno)); |
| label = gtk_label_new(error_char); |
| gtk_table_attach_defaults(popup_win->table, label, |
| 0, 1, 0, 1); |
| gtk_widget_show(label); |
| spec_info->display_widget = g_object_ref(GTK_WIDGET(label)); |
| goto end_it; |
| } |
| display_it: |
| info_list = _create_job_info_list(job_info_ptr, step_info_ptr, 1); |
| if (!info_list) |
| return; |
| |
| if (spec_info->view == ERROR_VIEW && spec_info->display_widget) { |
| gtk_widget_destroy(spec_info->display_widget); |
| spec_info->display_widget = NULL; |
| } |
| |
| if (spec_info->type != INFO_PAGE && !spec_info->display_widget) { |
| tree_view = create_treeview(local_display_data, |
| &popup_win->grid_button_list); |
| /*set multiple capability here*/ |
| gtk_tree_selection_set_mode( |
| gtk_tree_view_get_selection(tree_view), |
| GTK_SELECTION_MULTIPLE); |
| spec_info->display_widget = |
| g_object_ref(GTK_WIDGET(tree_view)); |
| gtk_table_attach_defaults(popup_win->table, |
| GTK_WIDGET(tree_view), |
| 0, 1, 0, 1); |
| /* since this function sets the model of the tree_view to the |
| * treestore we don't really care about the return value */ |
| create_treestore(tree_view, popup_win->display_data, |
| SORTID_CNT, SORTID_TIME_SUBMIT, SORTID_COLOR); |
| } |
| |
| setup_popup_grid_list(popup_win); |
| |
| spec_info->view = INFO_VIEW; |
| if (spec_info->type == INFO_PAGE) { |
| _display_info_job(info_list, popup_win); |
| goto end_it; |
| } |
| |
| |
| /* just linking to another list, don't free the inside, just |
| * the list */ |
| send_info_list = list_create(NULL); |
| itr = list_iterator_create(info_list); |
| while ((sview_job_info_ptr = list_next(itr))) { |
| job_ptr = sview_job_info_ptr->job_ptr; |
| switch (spec_info->type) { |
| case JOB_PAGE: |
| switch(search_info->search_type) { |
| case SEARCH_JOB_ID: |
| if (search_info->int_data |
| == NO_VAL) { |
| if (!search_info->gchar_data) |
| continue; |
| _convert_char_to_job_and_step( |
| search_info->gchar_data, |
| &search_info->int_data, |
| &search_info->int_data2); |
| } |
| if (job_ptr->job_id != search_info->int_data) { |
| continue; |
| } |
| #if 0 |
| /* if we ever want to display just the step |
| * this is where we would do it */ |
| if (spec_info->search_info->int_data2 |
| == NO_VAL) |
| break; |
| step_itr = list_iterator_create( |
| sview_job_info->step_list); |
| while ((step_ptr = list_next(itr))) { |
| if (step_ptr->step_id.step_id == |
| spec_info->search_info->int_data2) { |
| break; |
| } |
| } |
| #endif |
| break; |
| case SEARCH_JOB_USER: |
| if (!search_info->gchar_data) |
| continue; |
| uname = uid_to_string_cached(job_ptr->user_id); |
| name_diff = xstrcmp(uname, |
| search_info->gchar_data); |
| if (name_diff) |
| continue; |
| break; |
| case SEARCH_JOB_STATE: |
| if (search_info->int_data == NO_VAL) |
| continue; |
| |
| if (job_ptr->job_state != search_info->int_data) |
| continue; |
| break; |
| default: |
| break; |
| } |
| break; |
| case PART_PAGE: |
| if (xstrcmp(search_info->gchar_data, |
| job_ptr->partition)) |
| continue; |
| |
| if (search_info->cluster_name && |
| xstrcmp(search_info->cluster_name, |
| job_ptr->cluster)) |
| continue; |
| break; |
| case RESV_PAGE: |
| if (!job_ptr->resv_name |
| || xstrcmp(search_info->gchar_data, |
| job_ptr->resv_name)) |
| continue; |
| break; |
| case NODE_PAGE: |
| if (!job_ptr->nodes) |
| continue; |
| |
| if (!(hostset = hostset_create( |
| search_info->gchar_data))) |
| continue; |
| if (!hostset_intersects(hostset, job_ptr->nodes)) { |
| hostset_destroy(hostset); |
| continue; |
| } |
| hostset_destroy(hostset); |
| break; |
| default: |
| continue; |
| } |
| |
| list_push(send_info_list, sview_job_info_ptr); |
| top_node_inx = 0; |
| array_size = SVIEW_MAX_NODE_SPACE; |
| color_inx = xmalloc(sizeof(int) * array_size); |
| color_set_flag = xmalloc(sizeof(bool) * array_size); |
| j = 0; |
| while (job_ptr->node_inx[j] >= 0) { |
| top_node_inx = MAX(top_node_inx, |
| job_ptr->node_inx[j+1]); |
| if (top_node_inx > SVIEW_MAX_NODE_SPACE) |
| fatal("Increase SVIEW_MAX_NODE_SPACE in sview"); |
| for (k = job_ptr->node_inx[j]; |
| k <= job_ptr->node_inx[j+1]; k++) { |
| color_set_flag[k] = true; |
| color_inx[k] = sview_job_info_ptr->color_inx; |
| } |
| j += 2; |
| } |
| change_grid_color_array(popup_win->grid_button_list, |
| top_node_inx+1, color_inx, |
| color_set_flag, true, 0); |
| xfree(color_inx); |
| xfree(color_set_flag); |
| } |
| list_iterator_destroy(itr); |
| post_setup_popup_grid_list(popup_win); |
| |
| _update_info_job(send_info_list, |
| GTK_TREE_VIEW(spec_info->display_widget)); |
| |
| FREE_NULL_LIST(send_info_list); |
| end_it: |
| popup_win->toggled = 0; |
| popup_win->force_refresh = 0; |
| return; |
| } |
| |
| extern void set_menus_job(void *arg, void *arg2, GtkTreePath *path, int type) |
| { |
| GtkTreeView *tree_view = (GtkTreeView *)arg; |
| popup_info_t *popup_win = (popup_info_t *)arg; |
| GtkMenu *menu = (GtkMenu *)arg2; |
| list_t *button_list = arg2; |
| |
| switch(type) { |
| case TAB_CLICKED: |
| make_fields_menu(NULL, menu, display_data_job, SORTID_CNT); |
| break; |
| case ROW_CLICKED: |
| make_options_menu(tree_view, path, menu, options_data_job); |
| break; |
| case ROW_LEFT_CLICKED: |
| highlight_grid(tree_view, SORTID_NODE_INX, |
| SORTID_COLOR_INX, button_list); |
| break; |
| case FULL_CLICKED: |
| { |
| GtkTreeModel *model = gtk_tree_view_get_model(tree_view); |
| GtkTreeIter iter; |
| if (!gtk_tree_model_get_iter(model, &iter, path)) { |
| g_error("job error getting iter from model\n"); |
| break; |
| } |
| |
| popup_all_job(model, &iter, INFO_PAGE); |
| |
| break; |
| } |
| case POPUP_CLICKED: |
| make_fields_menu(popup_win, menu, |
| popup_win->display_data, SORTID_CNT); |
| break; |
| default: |
| g_error("UNKNOWN type %d given to set_fields\n", type); |
| } |
| } |
| |
| extern void popup_all_job(GtkTreeModel *model, GtkTreeIter *iter, int id) |
| { |
| char *name = NULL, *cluster_name = NULL; |
| char title[100] = {0}; |
| list_itr_t *itr = NULL; |
| popup_info_t *popup_win = NULL; |
| int jobid = NO_VAL; |
| int stepid = NO_VAL; |
| GError *error = NULL; |
| char *tmp_jobid = NULL, *offset; |
| |
| gtk_tree_model_get(model, iter, SORTID_JOBID, &tmp_jobid, -1); |
| if (!tmp_jobid) |
| return; |
| |
| offset = strchr(tmp_jobid, '('); |
| if (offset) |
| offset++; |
| else |
| offset = tmp_jobid; |
| jobid = _id_from_stepstr(offset); |
| g_free(tmp_jobid); |
| gtk_tree_model_get(model, iter, SORTID_JOBID_FORMATTED, &tmp_jobid, -1); |
| gtk_tree_model_get(model, iter, SORTID_CLUSTER_NAME, &cluster_name, -1); |
| |
| gtk_tree_model_get(model, iter, SORTID_ALLOC, &stepid, -1); |
| |
| if (stepid) |
| stepid = NO_VAL; |
| else { |
| stepid = jobid; |
| gtk_tree_model_get(model, iter, SORTID_POS, &jobid, -1); |
| } |
| |
| switch(id) { |
| case PART_PAGE: |
| if (stepid == NO_VAL) |
| snprintf(title, 100, "Partition with job %s", |
| tmp_jobid); |
| else |
| snprintf(title, 100, "Partition with job step %s", |
| tmp_jobid); |
| break; |
| case RESV_PAGE: |
| if (stepid == NO_VAL) |
| snprintf(title, 100, "Reservation with job %s", |
| tmp_jobid); |
| else |
| snprintf(title, 100, "Reservation with job step %s", |
| tmp_jobid); |
| break; |
| case NODE_PAGE: |
| if (stepid == NO_VAL) |
| snprintf(title, 100, |
| "Node(s) running job %s", tmp_jobid); |
| else |
| snprintf(title, 100, "Node(s) running job step %s", |
| tmp_jobid); |
| break; |
| case INFO_PAGE: |
| if (stepid == NO_VAL) |
| snprintf(title, 100, "Full info for job %s", tmp_jobid); |
| else |
| snprintf(title, 100, "Full info for job step %s", |
| tmp_jobid); |
| break; |
| default: |
| g_print("jobs got id %d\n", id); |
| } |
| |
| if (cluster_name && federation_name && |
| (cluster_flags & CLUSTER_FLAG_FED)) { |
| char *tmp_cname = |
| xstrdup_printf(" (%s:%s)", |
| federation_name, cluster_name); |
| strncat(title, tmp_cname, sizeof(title) - strlen(title) - 1); |
| xfree(tmp_cname); |
| } |
| |
| if (tmp_jobid) |
| g_free(tmp_jobid); |
| |
| itr = list_iterator_create(popup_list); |
| while ((popup_win = list_next(itr))) { |
| if (popup_win->spec_info) |
| if (!xstrcmp(popup_win->spec_info->title, title)) { |
| break; |
| } |
| } |
| list_iterator_destroy(itr); |
| |
| if (!popup_win) { |
| if (id == INFO_PAGE) |
| popup_win = create_popup_info(id, JOB_PAGE, title); |
| else |
| popup_win = create_popup_info(JOB_PAGE, id, title); |
| } else { |
| gtk_window_present(GTK_WINDOW(popup_win->popup)); |
| g_free(cluster_name); |
| return; |
| } |
| |
| /* Pass the model and the structs from the iter so we can always get |
| the current node_inx. |
| */ |
| popup_win->model = model; |
| popup_win->iter = *iter; |
| popup_win->node_inx_id = SORTID_NODE_INX; |
| |
| if (cluster_flags & CLUSTER_FLAG_FED) { |
| popup_win->spec_info->search_info->cluster_name = cluster_name; |
| cluster_name = NULL; |
| } |
| g_free(cluster_name); |
| |
| switch(id) { |
| case NODE_PAGE: |
| gtk_tree_model_get(model, iter, SORTID_NODELIST, &name, -1); |
| popup_win->spec_info->search_info->gchar_data = name; |
| break; |
| case PART_PAGE: |
| gtk_tree_model_get(model, iter, SORTID_PARTITION, &name, -1); |
| popup_win->spec_info->search_info->gchar_data = name; |
| break; |
| case RESV_PAGE: |
| gtk_tree_model_get(model, iter, SORTID_RESV_NAME, &name, -1); |
| popup_win->spec_info->search_info->gchar_data = name; |
| break; |
| case SUBMIT_PAGE: |
| break; |
| case INFO_PAGE: |
| popup_win->spec_info->search_info->int_data = jobid; |
| popup_win->spec_info->search_info->int_data2 = stepid; |
| break; |
| |
| default: |
| g_print("jobs got %d\n", id); |
| } |
| if (!sview_thread_new((gpointer)popup_thr, popup_win, &error)) { |
| g_printerr ("Failed to create part popup thread: %s\n", |
| error->message); |
| return; |
| } |
| } |
| |
| static void process_foreach_list(jobs_foreach_common_t *jobs_foreach_common) |
| { |
| int jobid; |
| int state; |
| int stepid; |
| uint16_t signal = SIGKILL; |
| int response = 0; |
| char *tmp_char_ptr = ""; |
| jobs_foreach_t *job_foreach = NULL; |
| list_itr_t *itr = NULL; |
| |
| if (jobs_foreach_common->edit_type == EDIT_SIGNAL) { |
| const gchar *entry_txt = gtk_entry_get_text( |
| GTK_ENTRY(jobs_foreach_common->entry)); |
| signal = _xlate_signal_name(entry_txt); |
| if (signal == NO_VAL16) { |
| tmp_char_ptr = g_strdup_printf( |
| "%s is not a valid signal.", |
| entry_txt); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| goto end_it; |
| } |
| } |
| |
| itr = list_iterator_create(foreach_list); |
| while ((job_foreach = list_next(itr))) { |
| /*stop processing remaining jobs on any error*/ |
| if (global_error_code) |
| break; |
| |
| jobid = job_foreach->step_id.job_id; |
| stepid = job_foreach->step_id.step_id; |
| state = job_foreach->state; |
| |
| switch(jobs_foreach_common->edit_type) { |
| case EDIT_SIGNAL: |
| /* fall through to the cancel now the signal |
| * is set (Default is SIGKILL from above for |
| * just a regular cancel). |
| */ |
| case EDIT_CANCEL: |
| if (stepid == NO_VAL) |
| global_error_code = |
| _cancel_job_id(jobid, signal); |
| else |
| global_error_code = |
| _cancel_step_id(jobid, |
| stepid, signal); |
| break; |
| case EDIT_REQUEUE: |
| response = slurm_requeue(jobid, 0); |
| |
| if (response) { |
| /* stop rest of jobs */ |
| global_error_code = response; |
| tmp_char_ptr = g_strdup_printf( |
| "Error happened trying " |
| "to requeue job %u: %s", |
| jobid, slurm_strerror(response)); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| } |
| break; |
| case EDIT_SUSPEND: |
| //note: derive state from job_foreach.. |
| if (state == JOB_SUSPENDED) |
| response = slurm_resume(jobid); |
| else |
| response = slurm_suspend(jobid); |
| if (!response) { |
| /* stop rest of jobs */ |
| global_error_code = response; |
| tmp_char_ptr = g_strdup_printf( |
| "Error happened trying to " |
| "SUSPEND/RESUME job %u.", |
| jobid); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| } |
| break; |
| default: |
| break; |
| |
| }/*end switch*/ |
| } /*spin thru selected jobs*/ |
| |
| if (global_edit_error || global_error_code) |
| goto end_it; |
| |
| switch (jobs_foreach_common->edit_type) { |
| case EDIT_SIGNAL: |
| tmp_char_ptr = g_strdup_printf( |
| "Signal successfully sent to job(s)%s", |
| stacked_job_list); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| break; |
| case EDIT_CANCEL: |
| tmp_char_ptr = g_strdup_printf( |
| "Cancel successful for job(s)%s", |
| stacked_job_list); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| break; |
| case EDIT_REQUEUE: |
| tmp_char_ptr = g_strdup_printf( |
| "Requeue successful for job(s)%s", |
| stacked_job_list); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| break; |
| case EDIT_SUSPEND: |
| tmp_char_ptr = g_strdup_printf( |
| "SUSPEND/RESUME action successful for job(s)%s", |
| stacked_job_list); |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| break; |
| default: |
| break; |
| |
| }/*end switch*/ |
| |
| end_it: |
| xfree(stacked_job_list); |
| |
| } /*process_foreach_list ^^^*/ |
| |
| static void selected_foreach_build_list(GtkTreeModel *model, |
| GtkTreePath *path, |
| GtkTreeIter *iter, |
| gpointer userdata) |
| { |
| uint32_t jobid = NO_VAL; |
| uint32_t stepid = NO_VAL; |
| uint32_t array_job_id = NO_VAL, array_task_id = NO_VAL; |
| uint32_t het_job_id = NO_VAL, het_job_offset = NO_VAL; |
| int state; |
| jobs_foreach_t *fe_ptr = NULL; |
| char *tmp_jobid, *offset, *end_ptr; |
| |
| gtk_tree_model_get(model, iter, SORTID_JOBID, &tmp_jobid, -1); |
| |
| if (!tmp_jobid) |
| return; |
| |
| offset = strchr(tmp_jobid, '('); |
| if (offset) { |
| if (strchr(tmp_jobid, '_')) { |
| array_job_id = strtol(tmp_jobid, &end_ptr, 10); |
| array_task_id = strtol(end_ptr+1, NULL, 10); |
| } else { |
| het_job_id = strtol(tmp_jobid, &end_ptr, 10); |
| het_job_offset = strtol(end_ptr+1, NULL, 10); |
| } |
| offset++; |
| } else |
| offset = tmp_jobid; |
| jobid = atoi(offset); |
| g_free(tmp_jobid); |
| |
| gtk_tree_model_get(model, iter, SORTID_ALLOC, &stepid, -1); |
| |
| if (stepid) |
| stepid = NO_VAL; |
| else { |
| stepid = jobid; |
| gtk_tree_model_get(model, iter, SORTID_POS, &jobid, -1); |
| } |
| |
| gtk_tree_model_get(model, iter, SORTID_STATE_NUM, &state, -1); |
| |
| /* alc mem for individual job processor target */ |
| fe_ptr = xmalloc(sizeof(jobs_foreach_t)); |
| fe_ptr->step_id.job_id = jobid; |
| fe_ptr->step_id.step_id = stepid; |
| fe_ptr->step_id.step_het_comp = NO_VAL; |
| fe_ptr->state = state; |
| fe_ptr->array_job_id = array_job_id; |
| fe_ptr->array_task_id = array_task_id; |
| fe_ptr->het_job_id = het_job_id; |
| fe_ptr->het_job_offset = het_job_offset; |
| |
| list_append(foreach_list, fe_ptr); /* stuff target away*/ |
| |
| if (stacked_job_list) |
| xstrcat(stacked_job_list, ", "); |
| else |
| xstrcat(stacked_job_list, ": "); |
| |
| if (array_task_id == NO_VAL && het_job_id == NO_VAL) |
| xstrfmtcat(stacked_job_list, "%u", jobid); |
| else if (het_job_id != NO_VAL) |
| xstrfmtcat(stacked_job_list, "%u+%u", het_job_id, |
| het_job_offset); |
| else |
| xstrfmtcat(stacked_job_list, "%u_%u", |
| array_job_id, array_task_id); |
| if (stepid != SLURM_BATCH_SCRIPT) |
| xstrfmtcat(stacked_job_list, ".%u", stepid); |
| } |
| |
| static void _edit_each_job(GtkTreeModel *model, GtkTreeIter *iter, |
| jobs_foreach_common_t *jobs_foreach_common) |
| { |
| int response; |
| GtkWidget *popup; |
| GtkWidget *label = NULL; |
| GtkWidget *entry = NULL; |
| char tmp_char[255]; |
| char *tmp_char_ptr = ""; |
| jobs_foreach_t *job_foreach = NULL; |
| job_desc_msg_t *job_msg; |
| list_itr_t *itr = NULL; |
| |
| itr = list_iterator_create(foreach_list); |
| while ((job_foreach = list_next(itr))) { |
| /*stop processing remaining jobs on any error*/ |
| if (global_error_code || got_edit_signal) |
| break; |
| |
| popup = gtk_dialog_new_with_buttons( |
| "Edit Job", |
| GTK_WINDOW(main_window), |
| GTK_DIALOG_MODAL | |
| GTK_DIALOG_DESTROY_WITH_PARENT, |
| NULL); |
| gtk_window_set_type_hint(GTK_WINDOW(popup), |
| GDK_WINDOW_TYPE_HINT_NORMAL); |
| gtk_window_set_transient_for(GTK_WINDOW(popup), NULL); |
| label = gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_OK, GTK_RESPONSE_OK); |
| gtk_window_set_default(GTK_WINDOW(popup), label); |
| gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, |
| GTK_RESPONSE_CANCEL); |
| gtk_dialog_add_button(GTK_DIALOG(popup), "Cancel all", |
| GTK_RESPONSE_DELETE_EVENT); |
| gtk_window_set_default_size(GTK_WINDOW(popup), 200, 400); |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Editing job %u think before you type", |
| job_foreach->step_id.job_id); |
| label = gtk_label_new(tmp_char); |
| |
| job_msg = xmalloc(sizeof(job_desc_msg_t)); |
| slurm_init_job_desc_msg(job_msg); |
| job_msg->job_id = job_foreach->step_id.job_id; |
| entry = _admin_full_edit_job(job_msg, model, iter); |
| gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), |
| label, false, false, 0); |
| if (entry) |
| gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), |
| entry, true, true, 0); |
| gtk_widget_show_all(popup); |
| response = gtk_dialog_run(GTK_DIALOG(popup)); |
| gtk_widget_destroy(popup); |
| |
| if (got_edit_signal || |
| (response == GTK_RESPONSE_DELETE_EVENT)) { |
| slurm_free_job_desc_msg(job_msg); |
| break; |
| } |
| |
| if (global_edit_error) { |
| tmp_char_ptr = global_edit_error_msg; |
| } else if (!global_send_update_msg || |
| (response == GTK_RESPONSE_CANCEL)) { |
| tmp_char_ptr = g_strdup_printf("No change detected."); |
| } else if (slurm_update_job(job_msg) |
| == SLURM_SUCCESS) { |
| tmp_char_ptr = g_strdup_printf( |
| "Job %u updated successfully", |
| job_foreach->step_id.job_id); |
| } else if (errno == ESLURM_DISABLED) { |
| tmp_char_ptr = g_strdup_printf( |
| "Can't edit that part of non-pending job %u.", |
| job_foreach->step_id.job_id); |
| } else { |
| tmp_char_ptr = g_strdup_printf( |
| "Problem updating job %u.", |
| job_foreach->step_id.job_id); |
| } |
| display_edit_note(tmp_char_ptr); |
| g_free(tmp_char_ptr); |
| slurm_free_job_desc_msg(job_msg); |
| } /*spin thru selected jobs*/ |
| |
| xfree(stacked_job_list); |
| |
| } /*process_foreach_list ^^^*/ |
| |
| static void _edit_jobs(GtkTreeModel *model, GtkTreeIter *iter, |
| char *type, GtkTreeView *treeview) |
| { |
| jobs_foreach_common_t job_foreach_common; |
| global_error_code = SLURM_SUCCESS; |
| /* setup working_sview_config that applies to ALL selections */ |
| memset(&job_foreach_common, 0, sizeof(jobs_foreach_common_t)); |
| job_foreach_common.type = type; |
| job_foreach_common.edit_type = EDIT_EDIT; |
| |
| /* create a list to stack the selected jobs */ |
| foreach_list = list_create(xfree_ptr); |
| /* build array of job(s) to process */ |
| if (treeview) { |
| gtk_tree_selection_selected_foreach( |
| gtk_tree_view_get_selection(treeview), |
| selected_foreach_build_list, NULL); |
| } else |
| selected_foreach_build_list(model, NULL, iter, NULL); |
| /* determine what to do with them/it */ |
| _edit_each_job(model, iter, &job_foreach_common); /*go do them*/ |
| FREE_NULL_LIST(foreach_list); |
| |
| return; |
| |
| } |
| |
| extern void admin_job(GtkTreeModel *model, GtkTreeIter *iter, |
| char *type, GtkTreeView *treeview) |
| { |
| int jobid = NO_VAL; |
| int stepid = NO_VAL; |
| int response = 0; |
| char tmp_char[255]; |
| int edit_type = 0; |
| job_desc_msg_t *job_msg; |
| GtkWidget *label = NULL; |
| GtkWidget *entry = NULL; |
| GtkWidget *popup; |
| char *tmp_jobid, *offset; |
| |
| if (xstrcmp(type, "Edit Job") == 0) |
| return _edit_jobs(model, iter, type, treeview); |
| |
| popup = gtk_dialog_new_with_buttons( |
| type, |
| GTK_WINDOW(main_window), |
| GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, |
| NULL); |
| gtk_window_set_type_hint(GTK_WINDOW(popup), |
| GDK_WINDOW_TYPE_HINT_NORMAL); |
| |
| gtk_window_set_transient_for(GTK_WINDOW(popup), NULL); |
| |
| gtk_tree_model_get(model, iter, SORTID_JOBID, &tmp_jobid, -1); |
| |
| if (!tmp_jobid) |
| return; |
| |
| offset = strchr(tmp_jobid, '('); |
| if (offset) |
| offset++; |
| else |
| offset = tmp_jobid; |
| jobid = atoi(offset); |
| g_free(tmp_jobid); |
| |
| gtk_tree_model_get(model, iter, SORTID_ALLOC, &stepid, -1); |
| if (stepid) |
| stepid = NO_VAL; |
| else { |
| stepid = jobid; |
| gtk_tree_model_get(model, iter, SORTID_POS, &jobid, -1); |
| } |
| |
| job_msg = xmalloc(sizeof(job_desc_msg_t)); |
| slurm_init_job_desc_msg(job_msg); |
| |
| if (!xstrcasecmp("Signal", type)) { |
| label = gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_OK, GTK_RESPONSE_OK); |
| gtk_window_set_default(GTK_WINDOW(popup), label); |
| gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); |
| |
| entry = create_entry(); |
| label = gtk_label_new("Signal?"); |
| edit_type = EDIT_SIGNAL; |
| } else if (!xstrcasecmp("Requeue", type)) { |
| label = gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_YES, GTK_RESPONSE_OK); |
| gtk_window_set_default(GTK_WINDOW(popup), label); |
| gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Are you sure you want to requeue these job(s)?"); |
| label = gtk_label_new(tmp_char); |
| edit_type = EDIT_REQUEUE; |
| } else if (!xstrcasecmp("Cancel", type)) { |
| label = gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_YES, GTK_RESPONSE_OK); |
| gtk_window_set_default(GTK_WINDOW(popup), label); |
| gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_NO, GTK_RESPONSE_CANCEL); |
| |
| if (stepid != SLURM_BATCH_SCRIPT) |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Are you sure you want to cancel " |
| "these job step(s)?"); |
| else |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Are you sure you want to cancel " |
| "these job(s)?"); |
| label = gtk_label_new(tmp_char); |
| edit_type = EDIT_CANCEL; |
| } else if (!xstrcasecmp("Suspend/Resume", type)) { |
| label = gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_YES, GTK_RESPONSE_OK); |
| gtk_window_set_default(GTK_WINDOW(popup), label); |
| gtk_dialog_add_button(GTK_DIALOG(popup), |
| GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); |
| |
| if (stepid != SLURM_BATCH_SCRIPT) |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Are you sure you want to toggle " |
| "suspend/resume on these job steps?"); |
| else |
| snprintf(tmp_char, sizeof(tmp_char), |
| "Are you sure you want to toggle " |
| "suspend/resume on these jobs?"); |
| label = gtk_label_new(tmp_char); |
| edit_type = EDIT_SUSPEND; |
| } |
| |
| gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), |
| label, false, false, 0); |
| if (entry) |
| gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), |
| entry, true, true, 0); |
| gtk_widget_show_all(popup); |
| response = gtk_dialog_run (GTK_DIALOG(popup)); |
| |
| if (response == GTK_RESPONSE_OK) { |
| jobs_foreach_common_t job_foreach_common; |
| global_error_code = SLURM_SUCCESS; |
| /* setup working_sview_config that applies to ALL selections */ |
| memset(&job_foreach_common, 0, sizeof(jobs_foreach_common_t)); |
| job_foreach_common.type = type; |
| job_foreach_common.edit_type = edit_type; |
| job_foreach_common.entry = entry; |
| |
| /* pass this ptr for single job selections */ |
| job_foreach_common.job_msg = job_msg; |
| |
| /* create a list to stack the selected jobs */ |
| foreach_list = list_create(xfree_ptr); |
| /* build array of job(s) to process */ |
| if (treeview) |
| gtk_tree_selection_selected_foreach( |
| gtk_tree_view_get_selection(treeview), |
| selected_foreach_build_list, NULL); |
| else |
| selected_foreach_build_list(model, NULL, iter, NULL); |
| /* determine what to do with them/it */ |
| process_foreach_list(&job_foreach_common); /*go do them*/ |
| FREE_NULL_LIST(foreach_list); |
| }/*response OK ^^*/ |
| /* switch back to standard cursor*/ |
| |
| global_entry_changed = 0; |
| slurm_free_job_desc_msg(job_msg); |
| gtk_widget_destroy(popup); |
| if (got_edit_signal) { |
| type = got_edit_signal; |
| got_edit_signal = NULL; |
| admin_job(model, iter, type, treeview); |
| xfree(type); |
| } |
| return; |
| } |
| |
| extern void cluster_change_job(void) |
| { |
| display_data_t *display_data = display_data_job; |
| while (display_data++) { |
| if (display_data->id == -1) |
| break; |
| |
| if (cluster_flags & CLUSTER_FLAG_FED) { |
| switch(display_data->id) { |
| case SORTID_CLUSTER_NAME: |
| display_data->show = true; |
| break; |
| } |
| } else { |
| switch(display_data->id) { |
| case SORTID_CLUSTER_NAME: |
| display_data->show = false; |
| break; |
| } |
| } |
| } |
| |
| get_info_job(NULL, NULL); |
| } |
