/*
* slurm_job_node_ready - report if nodes are ready for job to execute now
* IN job_id - slurm job id
* RET: READY_* values as defined in slurm.h
*/
extern int slurm_job_node_ready(uint32_t job_id)
{
slurm_msg_t req, resp;
job_id_msg_t msg;
int rc;
slurm_msg_t_init(&req);
slurm_msg_t_init(&resp);
req.msg_type = REQUEST_JOB_READY;
req.data = &msg;
msg.job_id = job_id;
if (slurm_send_recv_controller_msg(&req, &resp) < 0)
return READY_JOB_ERROR;
if (resp.msg_type == RESPONSE_JOB_READY) {
rc = ((return_code_msg_t *) resp.data)->return_code;
slurm_free_return_code_msg(resp.data);
} else if (resp.msg_type == RESPONSE_SLURM_RC) {
int job_rc = ((return_code_msg_t *) resp.data) ->
return_code;
if ((job_rc == ESLURM_INVALID_PARTITION_NAME) ||
(job_rc == ESLURM_INVALID_JOB_ID))
rc = READY_JOB_FATAL;
else /* EAGAIN */
rc = READY_JOB_ERROR;
slurm_free_return_code_msg(resp.data);
} else
rc = READY_JOB_ERROR;
return rc;
}
/*
* slurm_get_triggers - Get all event trigger information
* Use slurm_free_trigger() to free the memory allocated by this function
* RET 0 or a slurm error code
*/
extern int slurm_get_triggers (trigger_info_msg_t ** trigger_get)
{
int rc;
slurm_msg_t resp_msg;
slurm_msg_t req_msg;
trigger_info_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.record_count = 0;
req.trigger_array = NULL;
req_msg.msg_type = REQUEST_TRIGGER_GET;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_TRIGGER_GET:
*trigger_get = (trigger_info_msg_t *)resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS ;
}
/*
* slurm_set_schedlog_level - issue RPC to set slurm scheduler log level
* IN schedlog_level - requested scheduler log level
* RET 0 on success, otherwise return -1 and set errno to indicate the error
*/
int
slurm_set_schedlog_level (uint32_t schedlog_level)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
set_debug_level_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.debug_level = schedlog_level;
req_msg.msg_type = REQUEST_SET_SCHEDLOG_LEVEL;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_ctl_conf - issue RPC to get slurm control configuration
* information if changed since update_time
* IN update_time - time of current configuration data
* IN slurm_ctl_conf_ptr - place to store slurm control configuration
* pointer
* RET 0 on success, otherwise return -1 and set errno to indicate the error
* NOTE: free the response using slurm_free_ctl_conf
*/
int
slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **confp)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
last_update_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.last_update = update_time;
req_msg.msg_type = REQUEST_BUILD_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_BUILD_INFO:
*confp = (slurm_ctl_conf_info_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_burst_buffer_info - issue RPC to get slurm all burst buffer plugin
* information
* IN burst_buffer_info_msg_pptr - place to store a burst buffer configuration
* pointer
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_burst_buffer_info_msg
*/
extern int slurm_load_burst_buffer_info(burst_buffer_info_msg_t **
burst_buffer_info_msg_pptr)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_BURST_BUFFER_INFO;
req_msg.data = NULL;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_BURST_BUFFER_INFO:
*burst_buffer_info_msg_pptr = (burst_buffer_info_msg_t *)
resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*burst_buffer_info_msg_pptr = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_set_debugflags - issue RPC to set slurm controller debug flags
* IN debug_flags_plus - debug flags to be added
* IN debug_flags_minus - debug flags to be removed
* IN debug_flags_set - new debug flags value
* RET 0 on success, otherwise return -1 and set errno to indicate the error
*/
extern int
slurm_set_debugflags (uint32_t debug_flags_plus, uint32_t debug_flags_minus)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
set_debug_flags_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.debug_flags_minus = debug_flags_minus;
req.debug_flags_plus = debug_flags_plus;
req_msg.msg_type = REQUEST_SET_DEBUG_FLAGS;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
extern slurm_step_layout_t *
slurm_job_step_layout_get(uint32_t job_id, uint32_t step_id)
{
job_step_id_msg_t data;
slurm_msg_t req, resp;
int errnum;
slurm_msg_t_init(&req);
slurm_msg_t_init(&resp);
req.msg_type = REQUEST_STEP_LAYOUT;
req.data = &data;
data.job_id = job_id;
data.step_id = step_id;
if (slurm_send_recv_controller_msg(&req, &resp) < 0) {
return NULL;
}
switch (resp.msg_type) {
case RESPONSE_STEP_LAYOUT:
return (slurm_step_layout_t *)resp.data;
case RESPONSE_SLURM_RC:
errnum = ((return_code_msg_t *)resp.data)->return_code;
slurm_free_return_code_msg(resp.data);
errno = errnum;
return NULL;
default:
errno = SLURM_UNEXPECTED_MSG_ERROR;
return NULL;
}
}
/*
* Log string at slurmctld daemon
* IN level - message level, from src/common/log.h
* IN string - the string to write
* RET 0 on success, -1 on failure, see errno for details
*/
extern int log_ctld(uint16_t level, char *string)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
slurm_event_log_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.level = level;
req.string = string;
req_msg.msg_type = REQUEST_EVENT_LOG;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg,
working_cluster_rec) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc) {
slurm_seterrno_ret(rc);
return SLURM_ERROR;
}
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
static int _load_cluster_nodes(slurm_msg_t *req_msg,
node_info_msg_t **node_info_msg_pptr,
slurmdb_cluster_rec_t *cluster,
uint16_t show_flags)
{
slurm_msg_t resp_msg;
int rc;
slurm_msg_t_init(&resp_msg);
if (slurm_send_recv_controller_msg(req_msg, &resp_msg, cluster) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_NODE_INFO:
*node_info_msg_pptr = (node_info_msg_t *) resp_msg.data;
if (show_flags & SHOW_MIXED)
_set_node_mixed(*node_info_msg_pptr);
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*node_info_msg_pptr = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_SUCCESS;
}
/*
* slurm_load_topo - issue RPC to get slurm all switch topology configuration
* information
* IN node_info_msg_pptr - place to store a node configuration pointer
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_topo_info_msg
*/
extern int slurm_load_topo(topo_info_response_msg_t **resp)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_TOPO_INFO;
req_msg.data = NULL;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_TOPO_INFO:
*resp = (topo_info_response_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/* slurm_load_assoc_mgr_info()
*
* Load requested controller assoc_mgr state.
*
*/
extern int
slurm_load_assoc_mgr_info(assoc_mgr_info_request_msg_t *req,
assoc_mgr_info_msg_t **resp)
{
int cc;
slurm_msg_t msg_request;
slurm_msg_t msg_reply;
slurm_msg_t_init(&msg_request);
slurm_msg_t_init(&msg_reply);
msg_request.msg_type = REQUEST_ASSOC_MGR_INFO;
msg_request.data = req;
cc = slurm_send_recv_controller_msg(&msg_request, &msg_reply);
if (cc < 0)
return SLURM_ERROR;
switch (msg_reply.msg_type) {
case RESPONSE_ASSOC_MGR_INFO:
*resp = msg_reply.data;
break;
case RESPONSE_SLURM_RC:
cc = ((return_code_msg_t *)msg_reply.data)->return_code;
slurm_free_return_code_msg(msg_reply.data);
if (cc) /* slurm_seterrno_ret() is a macro ... sigh */
slurm_seterrno(cc);
return -1;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
static int _get_info(shares_request_msg_t *shares_req,
shares_response_msg_t **shares_resp)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_SHARE_INFO;
req_msg.data = shares_req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg,
working_cluster_rec) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_SHARE_INFO:
*shares_resp = (shares_response_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*shares_resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
static int _get_info(priority_factors_request_msg_t *factors_req,
priority_factors_response_msg_t **factors_resp)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_PRIORITY_FACTORS;
req_msg.data = factors_req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_PRIORITY_FACTORS:
*factors_resp =
(priority_factors_response_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*factors_resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
static int _load_cluster_parts(slurm_msg_t *req_msg,
partition_info_msg_t **resp,
slurmdb_cluster_rec_t *cluster)
{
slurm_msg_t resp_msg;
int rc;
slurm_msg_t_init(&resp_msg);
if (slurm_send_recv_controller_msg(req_msg, &resp_msg, cluster) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_PARTITION_INFO:
*resp = (partition_info_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_federation - issue RPC to get federation status from controller
* IN/OUT fed_pptr - place to store returned federation information.
* slurmdb_federation_rec_t treated as a void pointer to since
* slurm.h doesn't have ties to slurmdb.h.
* RET 0 or -1 on error
*/
extern int slurm_load_federation(void **fed_pptr)
{
int rc;
slurm_msg_t resp_msg;
slurm_msg_t req_msg;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_FED_INFO;
req_msg.data = NULL;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg,
working_cluster_rec) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_FED_INFO:
*fed_pptr = resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* Handle a return code message type.
* Sets errno to return code and returns it
*/
static int
_handle_rc_msg(slurm_msg_t *msg)
{
int rc = ((return_code_msg_t *) msg->data)->return_code;
slurm_free_return_code_msg(msg->data);
slurm_seterrno(rc);
return rc;
}
/*
* Handle a return code message type.
* if return code is nonzero, sets errno to return code and returns < 0.
* Otherwise, returns 0 (SLURM_SUCCES)
*/
static int
_handle_rc_msg(slurm_msg_t *msg)
{
int rc = ((return_code_msg_t *) msg->data)->return_code;
slurm_free_return_code_msg(msg->data);
if (rc)
slurm_seterrno_ret(rc);
else
return SLURM_SUCCESS;
}
/* slurm_load_licenses()
*
* Load requested licenses from the controller.
*
*/
extern int
slurm_load_licenses(time_t t,
license_info_msg_t **lic_info,
uint16_t show_flags)
{
int cc;
slurm_msg_t msg_request;
slurm_msg_t msg_reply;
struct license_info_request_msg req;
memset(&req, 0, sizeof(struct license_info_request_msg));
slurm_msg_t_init(&msg_request);
slurm_msg_t_init(&msg_reply);
msg_request.msg_type = REQUEST_LICENSE_INFO;
req.last_update = t;
req.show_flags = show_flags;
msg_request.data = &req;
cc = slurm_send_recv_controller_msg(&msg_request, &msg_reply,
working_cluster_rec);
if (cc < 0)
return SLURM_ERROR;
switch (msg_reply.msg_type) {
case RESPONSE_LICENSE_INFO:
*lic_info = msg_reply.data;
break;
case RESPONSE_SLURM_RC:
cc = ((return_code_msg_t *)msg_reply.data)->return_code;
slurm_free_return_code_msg(msg_reply.data);
if (cc) /* slurm_seterrno_ret() is a macro ... sigh */
slurm_seterrno(cc);
*lic_info = NULL;
return -1;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_block_info - issue RPC to get slurm all node select plugin
* information if changed since update_time
* IN update_time - time of current configuration data
* IN block_info_msg_pptr - place to store a node select configuration
* pointer
* IN show_flags - controls output form or filtering, see SHOW_FLAGS in slurm.h
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_block_info_msg
*/
extern int slurm_load_block_info (time_t update_time,
block_info_msg_t **block_info_msg_pptr,
uint16_t show_flags)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
block_info_request_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.last_update = update_time;
req.show_flags = show_flags;
req_msg.msg_type = REQUEST_BLOCK_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg,
working_cluster_rec) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_BLOCK_INFO:
*block_info_msg_pptr = (block_info_msg_t *)
resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*block_info_msg_pptr = NULL;
break;
default:
*block_info_msg_pptr = NULL;
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_SUCCESS;
}
/*
* slurm_get_job_steps - issue RPC to get specific slurm job step
* configuration information if changed since update_time.
* a job_id value of NO_VAL implies all jobs, a step_id value of
* NO_VAL implies all steps
* IN update_time - time of current configuration data
* IN job_id - get information for specific job id, NO_VAL for all jobs
* IN step_id - get information for specific job step id, NO_VAL for all
* job steps
* IN job_info_msg_pptr - place to store a job configuration pointer
* IN show_flags - job step filtering options
* RET 0 on success, otherwise return -1 and set errno to indicate the error
* NOTE: free the response using slurm_free_job_step_info_response_msg
*/
int
slurm_get_job_steps (time_t update_time, uint32_t job_id, uint32_t step_id,
job_step_info_response_msg_t **resp, uint16_t show_flags)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
job_step_info_request_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.last_update = update_time;
req.job_id = job_id;
req.step_id = step_id;
req.show_flags = show_flags;
req_msg.msg_type = REQUEST_JOB_STEP_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_JOB_STEP_INFO:
*resp = (job_step_info_response_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_node_single - issue RPC to get slurm configuration information
* for a specific node
* OUT resp - place to store a node configuration pointer
* IN node_name - name of the node for which information is requested
* IN show_flags - node filtering options
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_node_info_msg
*/
extern int slurm_load_node_single (node_info_msg_t **resp,
char *node_name, uint16_t show_flags)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
node_info_single_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.node_name = node_name;
req.show_flags = show_flags;
req_msg.msg_type = REQUEST_NODE_INFO_SINGLE;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_NODE_INFO:
*resp = (node_info_msg_t *) resp_msg.data;
if (show_flags & SHOW_MIXED)
_set_node_mixed(*resp);
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_partitions - issue RPC to get slurm all partition configuration
* information if changed since update_time
* IN update_time - time of current configuration data
* IN partition_info_msg_pptr - place to store a partition configuration
* pointer
* IN show_flags - partition filtering options
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_partition_info_msg
*/
extern int slurm_load_partitions (time_t update_time,
partition_info_msg_t **resp,
uint16_t show_flags)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
part_info_request_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.last_update = update_time;
req.show_flags = show_flags;
req_msg.msg_type = REQUEST_PARTITION_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_PARTITION_INFO:
*resp = (partition_info_msg_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
*resp = NULL;
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_load_job_user - issue RPC to get slurm information about all jobs
* to be run as the specified user
* IN/OUT job_info_msg_pptr - place to store a job configuration pointer
* IN user_id - ID of user we want information for
* IN show_flags - job filtering options
* RET 0 or -1 on error
* NOTE: free the response using slurm_free_job_info_msg
*/
extern int slurm_load_job_user (job_info_msg_t **job_info_msg_pptr,
uint32_t user_id,
uint16_t show_flags)
{
int rc;
slurm_msg_t resp_msg;
slurm_msg_t req_msg;
job_user_id_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.show_flags = show_flags;
req.user_id = user_id;
req_msg.msg_type = REQUEST_JOB_USER_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case RESPONSE_JOB_INFO:
*job_info_msg_pptr = (job_info_msg_t *)resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_get_end_time - get the expected end time for a given slurm job
* IN jobid - slurm job id
* end_time_ptr - location in which to store scheduled end time for job
* RET 0 or -1 on error
*/
extern int
slurm_get_end_time(uint32_t jobid, time_t *end_time_ptr)
{
int rc;
slurm_msg_t resp_msg;
slurm_msg_t req_msg;
job_alloc_info_msg_t job_msg;
srun_timeout_msg_t *timeout_msg;
time_t now = time(NULL);
static uint32_t jobid_cache = 0;
static uint32_t jobid_env = 0;
static time_t endtime_cache = 0;
static time_t last_test_time = 0;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
if (!end_time_ptr)
slurm_seterrno_ret(EINVAL);
if (jobid == 0) {
if (jobid_env) {
jobid = jobid_env;
} else {
char *env = getenv("SLURM_JOB_ID");
if (env) {
jobid = (uint32_t) atol(env);
jobid_env = jobid;
}
}
if (jobid == 0) {
slurm_seterrno(ESLURM_INVALID_JOB_ID);
return SLURM_ERROR;
}
}
/* Just use cached data if data less than 60 seconds old */
if ((jobid == jobid_cache)
&& (difftime(now, last_test_time) < 60)) {
*end_time_ptr = endtime_cache;
return SLURM_SUCCESS;
}
job_msg.job_id = jobid;
req_msg.msg_type = REQUEST_JOB_END_TIME;
req_msg.data = &job_msg;
if (slurm_send_recv_controller_msg(
&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
case SRUN_TIMEOUT:
timeout_msg = (srun_timeout_msg_t *) resp_msg.data;
last_test_time = time(NULL);
jobid_cache = jobid;
endtime_cache = timeout_msg->timeout;
*end_time_ptr = endtime_cache;
slurm_free_srun_timeout_msg(resp_msg.data);
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (endtime_cache)
*end_time_ptr = endtime_cache;
else if (rc)
slurm_seterrno_ret(rc);
break;
default:
if (endtime_cache)
*end_time_ptr = endtime_cache;
else
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_SUCCESS;
}
/*
* slurm_load_slurmd_status - issue RPC to get the status of slurmd
* daemon on this machine
* IN slurmd_info_ptr - place to store slurmd status information
* RET 0 or -1 on error
* NOTE: free the response using slurm_free_slurmd_status()
*/
extern int
slurm_load_slurmd_status(slurmd_status_t **slurmd_status_ptr)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char *this_addr;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
if (cluster_flags & CLUSTER_FLAG_MULTSD) {
if ((this_addr = getenv("SLURMD_NODENAME"))) {
slurm_conf_get_addr(this_addr, &req_msg.address);
} else {
this_addr = "localhost";
slurm_set_addr(&req_msg.address,
(uint16_t)slurm_get_slurmd_port(),
this_addr);
}
} else {
char this_host[256];
/*
* Set request message address to slurmd on localhost
*/
gethostname_short(this_host, sizeof(this_host));
this_addr = slurm_conf_get_nodeaddr(this_host);
if (this_addr == NULL)
this_addr = xstrdup("localhost");
slurm_set_addr(&req_msg.address,
(uint16_t)slurm_get_slurmd_port(),
this_addr);
xfree(this_addr);
}
req_msg.msg_type = REQUEST_DAEMON_STATUS;
req_msg.data = NULL;
rc = slurm_send_recv_node_msg(&req_msg, &resp_msg, 0);
if ((rc != 0) || !resp_msg.auth_cred) {
error("slurm_slurmd_info: %m");
if (resp_msg.auth_cred)
g_slurm_auth_destroy(resp_msg.auth_cred);
return SLURM_ERROR;
}
if (resp_msg.auth_cred)
g_slurm_auth_destroy(resp_msg.auth_cred);
switch (resp_msg.msg_type) {
case RESPONSE_SLURMD_STATUS:
*slurmd_status_ptr = (slurmd_status_t *) resp_msg.data;
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* slurm_get_node_energy_n - issue RPC to get the energy data of all
* configured sensors on the target machine
* IN host - name of node to query, NULL if localhost
* IN delta - Use cache if data is newer than this in seconds
* OUT sensors_cnt - number of sensors
* OUT energy - array of acct_gather_energy_t structures on success or
* NULL other wise
* RET 0 on success or a slurm error code
* NOTE: free the response using xfree
*/
extern int slurm_get_node_energy(char *host, uint16_t delta,
uint16_t *sensor_cnt,
acct_gather_energy_t **energy)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
acct_gather_energy_req_msg_t req;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char *this_addr;
xassert(sensor_cnt);
xassert(energy);
*sensor_cnt = 0;
*energy = NULL;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
if (host)
slurm_conf_get_addr(host, &req_msg.address);
else if (cluster_flags & CLUSTER_FLAG_MULTSD) {
if ((this_addr = getenv("SLURMD_NODENAME"))) {
slurm_conf_get_addr(this_addr, &req_msg.address);
} else {
this_addr = "localhost";
slurm_set_addr(&req_msg.address,
(uint16_t)slurm_get_slurmd_port(),
this_addr);
}
} else {
char this_host[256];
/*
* Set request message address to slurmd on localhost
*/
gethostname_short(this_host, sizeof(this_host));
this_addr = slurm_conf_get_nodeaddr(this_host);
if (this_addr == NULL)
this_addr = xstrdup("localhost");
slurm_set_addr(&req_msg.address,
(uint16_t)slurm_get_slurmd_port(),
this_addr);
xfree(this_addr);
}
req.delta = delta;
req_msg.msg_type = REQUEST_ACCT_GATHER_ENERGY;
req_msg.data = &req;
rc = slurm_send_recv_node_msg(&req_msg, &resp_msg, 0);
if (rc != 0 || !resp_msg.auth_cred) {
error("slurm_get_node_energy: %m");
if (resp_msg.auth_cred)
g_slurm_auth_destroy(resp_msg.auth_cred);
return SLURM_ERROR;
}
if (resp_msg.auth_cred)
g_slurm_auth_destroy(resp_msg.auth_cred);
switch (resp_msg.msg_type) {
case RESPONSE_ACCT_GATHER_ENERGY:
*sensor_cnt = ((acct_gather_node_resp_msg_t *)
resp_msg.data)->sensor_cnt;
*energy = ((acct_gather_node_resp_msg_t *)
resp_msg.data)->energy;
((acct_gather_node_resp_msg_t *) resp_msg.data)->energy = NULL;
slurm_free_acct_gather_node_resp_msg(resp_msg.data);
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
break;
default:
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
return SLURM_PROTOCOL_SUCCESS;
}
/*
* We don't use the api here because it does things we aren't needing
* like printing out information and not returning times.
*/
local_cluster_rec_t *_job_will_run (job_desc_msg_t *req)
{
slurm_msg_t req_msg, resp_msg;
will_run_response_msg_t *will_run_resp;
int rc;
char buf[64];
char *type = "processors";
local_cluster_rec_t *local_cluster = NULL;
/* req.immediate = true; implicit */
slurm_msg_t_init(&req_msg);
req_msg.msg_type = REQUEST_JOB_WILL_RUN;
req_msg.data = req;
rc = slurm_send_recv_controller_msg(&req_msg, &resp_msg);
if (rc < 0) {
slurm_seterrno(SLURM_SOCKET_ERROR);
return NULL;
}
switch (resp_msg.msg_type) {
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno(rc);
break;
case RESPONSE_JOB_WILL_RUN:
if (working_cluster_rec->flags & CLUSTER_FLAG_BG)
type = "cnodes";
will_run_resp = (will_run_response_msg_t *) resp_msg.data;
slurm_make_time_str(&will_run_resp->start_time,
buf, sizeof(buf));
debug("Job %u to start at %s on cluster %s using %u %s on %s",
will_run_resp->job_id, buf, working_cluster_rec->name,
will_run_resp->proc_cnt, type,
will_run_resp->node_list);
local_cluster = xmalloc(sizeof(local_cluster_rec_t));
local_cluster->cluster_rec = working_cluster_rec;
local_cluster->start_time = will_run_resp->start_time;
if (will_run_resp->preemptee_job_id) {
local_cluster->preempt_cnt =
list_count(will_run_resp->preemptee_job_id);
if (opt.verbose >= LOG_LEVEL_DEBUG) {
ListIterator itr;
uint32_t *job_id_ptr;
char *job_list = NULL, *sep = "";
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u",
sep, *job_id_ptr);
}
debug(" Preempts: %s", job_list);
xfree(job_list);
}
}
slurm_free_will_run_response_msg(will_run_resp);
break;
default:
slurm_seterrno(SLURM_UNEXPECTED_MSG_ERROR);
return NULL;
break;
}
return local_cluster;
}
