extern int slurm_persist_unpack_rc_msg( persist_rc_msg_t **msg, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; persist_rc_msg_t *msg_ptr = xmalloc(sizeof(persist_rc_msg_t)); *msg = msg_ptr; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->comment, &uint32_tmp, buffer); safe_unpack16(&msg_ptr->flags, buffer); safe_unpack32(&msg_ptr->rc, buffer); safe_unpack16(&msg_ptr->ret_info, buffer); } else { error("%s: invalid protocol_version %u", __func__, protocol_version); goto unpack_error; } return SLURM_SUCCESS; unpack_error: slurm_persist_free_rc_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_return_code(uint16_t rpc_version, Buf buffer) { uint16_t msg_type = -1; persist_rc_msg_t *msg; dbd_id_rc_msg_t *id_msg; slurmdbd_msg_t resp; int rc = SLURM_ERROR; memset(&resp, 0, sizeof(slurmdbd_msg_t)); if ((rc = unpack_slurmdbd_msg(&resp, slurmdbd_conn->version, buffer)) != SLURM_SUCCESS) { error("%s: unpack message error", __func__); return rc; } switch (resp.msg_type) { case DBD_ID_RC: id_msg = resp.data; rc = id_msg->return_code; slurmdbd_free_id_rc_msg(id_msg); if (rc != SLURM_SUCCESS) error("slurmdbd: DBD_ID_RC is %d", rc); break; case PERSIST_RC: msg = resp.data; rc = msg->rc; if (rc != SLURM_SUCCESS) { if (msg->ret_info == DBD_REGISTER_CTLD && slurm_get_accounting_storage_enforce()) { error("slurmdbd: PERSIST_RC is %d from " "%s(%u): %s", rc, slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->comment); fatal("You need to add this cluster " "to accounting if you want to " "enforce associations, or no " "jobs will ever run."); } else debug("slurmdbd: PERSIST_RC is %d from " "%s(%u): %s", rc, slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->comment); } slurm_persist_free_rc_msg(msg); break; default: error("slurmdbd: bad message type %d != PERSIST_RC", msg_type); } return rc; }
/* Send an RPC to the SlurmDBD and wait for the return code reply. * The RPC will not be queued if an error occurs. * Returns SLURM_SUCCESS or an error code */ extern int send_slurmdbd_recv_rc_msg(uint16_t rpc_version, slurmdbd_msg_t *req, int *resp_code) { int rc; slurmdbd_msg_t resp; xassert(req); xassert(resp_code); memset(&resp, 0, sizeof(slurmdbd_msg_t)); rc = send_recv_slurmdbd_msg(rpc_version, req, &resp); if (rc != SLURM_SUCCESS) { ; /* error message already sent */ } else if (resp.msg_type != PERSIST_RC) { error("slurmdbd: response is not type PERSIST_RC: %s(%u)", slurmdbd_msg_type_2_str(resp.msg_type, 1), resp.msg_type); rc = SLURM_ERROR; } else { /* resp.msg_type == PERSIST_RC */ persist_rc_msg_t *msg = resp.data; *resp_code = msg->rc; if (msg->rc != SLURM_SUCCESS && msg->rc != ACCOUNTING_FIRST_REG && msg->rc != ACCOUNTING_TRES_CHANGE_DB && msg->rc != ACCOUNTING_NODES_CHANGE_DB) { char *comment = msg->comment; if (!comment) comment = slurm_strerror(msg->rc); if (msg->ret_info == DBD_REGISTER_CTLD && slurm_get_accounting_storage_enforce()) { error("slurmdbd: Issue with call " "%s(%u): %u(%s)", slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->rc, comment); fatal("You need to add this cluster " "to accounting if you want to " "enforce associations, or no " "jobs will ever run."); } else debug("slurmdbd: Issue with call " "%s(%u): %u(%s)", slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->rc, comment); } slurm_persist_free_rc_msg(msg); } return rc; }
extern int slurm_persist_unpack_rc_msg( persist_rc_msg_t **msg, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; persist_rc_msg_t *msg_ptr = xmalloc(sizeof(persist_rc_msg_t)); *msg = msg_ptr; safe_unpackstr_xmalloc(&msg_ptr->comment, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->rc, buffer); safe_unpack16(&msg_ptr->ret_info, buffer); return SLURM_SUCCESS; unpack_error: slurm_persist_free_rc_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
/* Open a persistent socket connection * IN/OUT - persistent connection needing rem_host and rem_port filled in. * Returned completely filled in. * Returns SLURM_SUCCESS on success or SLURM_ERROR on failure */ extern int slurm_persist_conn_open(slurm_persist_conn_t *persist_conn) { int rc = SLURM_ERROR; slurm_msg_t req_msg; persist_init_req_msg_t req; persist_rc_msg_t *resp = NULL; if (slurm_persist_conn_open_without_init(persist_conn) != SLURM_SUCCESS) return rc; slurm_msg_t_init(&req_msg); /* Always send the lowest protocol since we don't know what version the * other side is running yet. */ req_msg.protocol_version = persist_conn->version; req_msg.msg_type = REQUEST_PERSIST_INIT; req_msg.flags |= SLURM_GLOBAL_AUTH_KEY; if (persist_conn->flags & PERSIST_FLAG_DBD) req_msg.flags |= SLURMDBD_CONNECTION; memset(&req, 0, sizeof(persist_init_req_msg_t)); req.cluster_name = persist_conn->cluster_name; req.persist_type = persist_conn->persist_type; req.port = persist_conn->my_port; req.version = SLURM_PROTOCOL_VERSION; req_msg.data = &req; if (slurm_send_node_msg(persist_conn->fd, &req_msg) < 0) { error("%s: failed to send persistent connection init message to %s:%d", __func__, persist_conn->rem_host, persist_conn->rem_port); _close_fd(&persist_conn->fd); } else { Buf buffer = slurm_persist_recv_msg(persist_conn); persist_msg_t msg; slurm_persist_conn_t persist_conn_tmp; if (!buffer) { if (_comm_fail_log(persist_conn)) { error("%s: No response to persist_init", __func__); } _close_fd(&persist_conn->fd); goto end_it; } memset(&msg, 0, sizeof(persist_msg_t)); memcpy(&persist_conn_tmp, persist_conn, sizeof(slurm_persist_conn_t)); /* The first unpack is done the same way for dbd or normal * communication . */ persist_conn_tmp.flags &= (~PERSIST_FLAG_DBD); rc = slurm_persist_msg_unpack(&persist_conn_tmp, &msg, buffer); free_buf(buffer); resp = (persist_rc_msg_t *)msg.data; if (resp && (rc == SLURM_SUCCESS)) { rc = resp->rc; persist_conn->version = resp->ret_info; persist_conn->flags |= resp->flags; } if (rc != SLURM_SUCCESS) { if (resp) { error("%s: Something happened with the receiving/processing of the persistent connection init message to %s:%d: %s", __func__, persist_conn->rem_host, persist_conn->rem_port, resp->comment); } else { error("%s: Failed to unpack persistent connection init resp message from %s:%d", __func__, persist_conn->rem_host, persist_conn->rem_port); } _close_fd(&persist_conn->fd); } } end_it: slurm_persist_free_rc_msg(resp); return rc; }
static int _handle_mult_rc_ret(void) { Buf buffer; uint16_t msg_type; persist_rc_msg_t *msg = NULL; dbd_list_msg_t *list_msg = NULL; int rc = SLURM_ERROR; Buf out_buf = NULL; buffer = slurm_persist_recv_msg(slurmdbd_conn); if (buffer == NULL) return rc; safe_unpack16(&msg_type, buffer); switch (msg_type) { case DBD_GOT_MULT_MSG: if (slurmdbd_unpack_list_msg( &list_msg, slurmdbd_conn->version, DBD_GOT_MULT_MSG, buffer) != SLURM_SUCCESS) { error("slurmdbd: unpack message error"); break; } slurm_mutex_lock(&agent_lock); if (agent_list) { ListIterator itr = list_iterator_create(list_msg->my_list); while ((out_buf = list_next(itr))) { Buf b; if ((rc = _unpack_return_code( slurmdbd_conn->version, out_buf)) != SLURM_SUCCESS) break; if ((b = list_dequeue(agent_list))) { free_buf(b); } else { error("slurmdbd: DBD_GOT_MULT_MSG " "unpack message error"); } } list_iterator_destroy(itr); } slurm_mutex_unlock(&agent_lock); slurmdbd_free_list_msg(list_msg); break; case PERSIST_RC: if (slurm_persist_unpack_rc_msg( &msg, buffer, slurmdbd_conn->version) == SLURM_SUCCESS) { rc = msg->rc; if (rc != SLURM_SUCCESS) { if (msg->ret_info == DBD_REGISTER_CTLD && slurm_get_accounting_storage_enforce()) { error("slurmdbd: PERSIST_RC is %d from " "%s(%u): %s", rc, slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->comment); fatal("You need to add this cluster " "to accounting if you want to " "enforce associations, or no " "jobs will ever run."); } else debug("slurmdbd: PERSIST_RC is %d from " "%s(%u): %s", rc, slurmdbd_msg_type_2_str( msg->ret_info, 1), msg->ret_info, msg->comment); } slurm_persist_free_rc_msg(msg); } else error("slurmdbd: unpack message error"); break; default: error("slurmdbd: bad message type %d != PERSIST_RC", msg_type); } unpack_error: free_buf(buffer); return rc; }