/src/slurmdbd/proc_req.c
C | 3599 lines | 3113 code | 392 blank | 94 comment | 659 complexity | b9798d7e544059e4133a50c710d197b1 MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0
- /*****************************************************************************\
- * proc_req.c - functions for processing incoming RPCs.
- *****************************************************************************
- * Copyright (C) 2008-2010 Lawrence Livermore National Security.
- * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
- * Written by Morris Jette <jette1@llnl.gov>, 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 <http://www.schedmd.com/slurmdocs/>.
- * 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.
- *
- * In addition, as a special exception, the copyright holders give permission
- * to link the code of portions of this program with the OpenSSL library under
- * certain conditions as described in each individual source file, and
- * distribute linked combinations including the two. You must obey the GNU
- * General Public License in all respects for all of the code used other than
- * OpenSSL. If you modify file(s) with this exception, you may extend this
- * exception to your version of the file(s), but you are not obligated to do
- * so. If you do not wish to do so, delete this exception statement from your
- * version. If you delete this exception statement from all source files in
- * the program, then also delete it here.
- *
- * 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 "src/common/gres.h"
- #include "src/common/macros.h"
- #include "src/common/pack.h"
- #include "src/common/slurmdbd_defs.h"
- #include "src/common/slurm_accounting_storage.h"
- #include "src/common/slurm_jobacct_gather.h"
- #include "src/common/slurm_protocol_api.h"
- #include "src/common/slurm_protocol_defs.h"
- #include "src/common/uid.h"
- #include "src/common/xstring.h"
- #include "src/slurmdbd/read_config.h"
- #include "src/slurmdbd/rpc_mgr.h"
- #include "src/slurmdbd/proc_req.h"
- #include "src/slurmctld/slurmctld.h"
- /* Local functions */
- static int _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _archive_load(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _cluster_cpus(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_config(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_events(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_probs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_txn(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_usage(uint16_t type, slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _init_conn(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _fini_conn(slurmdbd_conn_t *slurmdbd_conn, Buf in_buffer,
- Buf *out_buffer);
- static int _job_complete(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _job_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_job(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _node_state(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static char *_node_state_string(uint16_t node_state);
- static void _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
- dbd_job_start_msg_t *job_start_msg,
- dbd_id_rc_msg_t *id_rc_msg);
- static int _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid);
- static int _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid);
- static int _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid);
- static int _step_complete(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- static int _step_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid);
- /* Process an incoming RPC
- * slurmdbd_conn IN/OUT - in will that the newsockfd set before
- * calling and db_conn and rpc_version will be filled in with the init.
- * msg IN - incoming message
- * msg_size IN - size of msg in bytes
- * first IN - set if first message received on the socket
- * buffer OUT - outgoing response, must be freed by caller
- * uid IN/OUT - user ID who initiated the RPC
- * RET SLURM_SUCCESS or error code */
- extern int
- proc_req(slurmdbd_conn_t *slurmdbd_conn,
- char *msg, uint32_t msg_size,
- bool first, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- uint16_t msg_type;
- Buf in_buffer;
- char *comment = NULL;
- in_buffer = create_buf(msg, msg_size); /* puts msg into buffer struct */
- safe_unpack16(&msg_type, in_buffer);
- errno = 0; /* clear errno */
- if (first && (msg_type != DBD_INIT)) {
- comment = "Initial RPC not DBD_INIT";
- error("CONN:%u %s type (%d)",
- slurmdbd_conn->newsockfd, comment, msg_type);
- rc = EINVAL;
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_INIT);
- } else {
- switch (msg_type) {
- case DBD_ADD_ACCOUNTS:
- rc = _add_accounts(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_ACCOUNT_COORDS:
- rc = _add_account_coords(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_ASSOCS:
- rc = _add_assocs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_CLUSTERS:
- rc = _add_clusters(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_QOS:
- rc = _add_qos(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_USERS:
- rc = _add_users(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_WCKEYS:
- rc = _add_wckeys(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ADD_RESV:
- rc = _add_reservation(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ARCHIVE_DUMP:
- rc = _archive_dump(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ARCHIVE_LOAD:
- rc = _archive_load(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_CLUSTER_CPUS:
- rc = _cluster_cpus(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_ACCOUNTS:
- rc = _get_accounts(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_ASSOCS:
- rc = _get_assocs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_ASSOC_USAGE:
- case DBD_GET_CLUSTER_USAGE:
- rc = _get_usage(msg_type, slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_CLUSTERS:
- rc = _get_clusters(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_CONFIG:
- rc = _get_config(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_EVENTS:
- rc = _get_events(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_JOBS_COND:
- rc = _get_jobs_cond(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_PROBS:
- rc = _get_probs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_QOS:
- rc = _get_qos(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_TXN:
- rc = _get_txn(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_WCKEYS:
- rc = _get_wckeys(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_RESVS:
- rc = _get_reservations(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_USERS:
- rc = _get_users(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_FLUSH_JOBS:
- rc = _flush_jobs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_INIT:
- if (first)
- rc = _init_conn(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- else {
- comment = "DBD_INIT sent after connection established";
- error("CONN:%u %s",
- slurmdbd_conn->newsockfd, comment);
- rc = EINVAL;
- *out_buffer = make_dbd_rc_msg(
- slurmdbd_conn->rpc_version, rc, comment,
- DBD_INIT);
- }
- break;
- case DBD_FINI:
- rc = _fini_conn(slurmdbd_conn, in_buffer, out_buffer);
- break;
- case DBD_JOB_COMPLETE:
- rc = _job_complete(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_JOB_START:
- rc = _job_start(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_JOB_SUSPEND:
- rc = _job_suspend(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_ACCOUNTS:
- rc = _modify_accounts(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_ASSOCS:
- rc = _modify_assocs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_CLUSTERS:
- rc = _modify_clusters(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_JOB:
- rc = _modify_job(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_QOS:
- rc = _modify_qos(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_USERS:
- rc = _modify_users(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_WCKEYS:
- rc = _modify_wckeys(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_MODIFY_RESV:
- rc = _modify_reservation(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_NODE_STATE:
- rc = _node_state(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REGISTER_CTLD:
- rc = _register_ctld(slurmdbd_conn, in_buffer,
- out_buffer, uid);
- break;
- case DBD_REMOVE_ACCOUNTS:
- rc = _remove_accounts(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_ACCOUNT_COORDS:
- rc = _remove_account_coords(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_ASSOCS:
- rc = _remove_assocs(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_CLUSTERS:
- rc = _remove_clusters(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_QOS:
- rc = _remove_qos(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_USERS:
- rc = _remove_users(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_WCKEYS:
- rc = _remove_wckeys(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_REMOVE_RESV:
- rc = _remove_reservation(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_ROLL_USAGE:
- rc = _roll_usage(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_SEND_MULT_JOB_START:
- rc = _send_mult_job_start(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_SEND_MULT_MSG:
- rc = _send_mult_msg(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_STEP_COMPLETE:
- rc = _step_complete(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_STEP_START:
- rc = _step_start(slurmdbd_conn,
- in_buffer, out_buffer, uid);
- break;
- case DBD_GET_JOBS:
- /* Defunct RPC */
- default:
- comment = "Invalid RPC";
- error("CONN:%u %s msg_type=%d",
- slurmdbd_conn->newsockfd, comment, msg_type);
- rc = EINVAL;
- *out_buffer = make_dbd_rc_msg(
- slurmdbd_conn->rpc_version, rc, comment, 0);
- break;
- }
- if (rc == ESLURM_ACCESS_DENIED)
- error("CONN:%u Security violation, %s",
- slurmdbd_conn->newsockfd,
- slurmdbd_msg_type_2_str(msg_type, 1));
- }
- xfer_buf_data(in_buffer); /* delete in_buffer struct without
- * xfree of msg */
- return rc;
- unpack_error:
- free_buf(in_buffer);
- return SLURM_ERROR;
- }
- /* replace \" with \` return is the same as what is given */
- static char * _replace_double_quotes(char *option)
- {
- int i=0;
- if (!option)
- return NULL;
- while (option[i]) {
- if (option[i] == '\"')
- option[i] = '`';
- i++;
- }
- return option;
- }
- static int _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_ACCOUNTS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- slurmdb_user_rec_t user;
- memset(&user, 0, sizeof(slurmdb_user_rec_t));
- user.uid = *uid;
- if (assoc_mgr_fill_in_user(
- slurmdbd_conn->db_conn, &user, 1, NULL)
- != SLURM_SUCCESS) {
- comment = "Your user has not been added to the accounting system yet.";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- if (!user.coord_accts || !list_count(user.coord_accts)) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- /* If the user is a coord of any acct they can add
- * accounts they are only able to make associations to
- * these accounts if they are coordinators of the
- * parent they are trying to add to
- */
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_ACCOUNTS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_ACCOUNTS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_add_accounts(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_ACCOUNTS);
- return rc;
- }
- static int _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_acct_coord_msg_t *get_msg = NULL;
- char *comment = NULL;
- if (slurmdbd_unpack_acct_coord_msg(
- &get_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_ACCOUNT_COORDS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_ADD_ACCOUNT_COORDS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- ListIterator itr = NULL;
- ListIterator itr2 = NULL;
- slurmdb_user_rec_t user;
- slurmdb_coord_rec_t *coord = NULL;
- char *acct = NULL;
- int bad = 0;
- memset(&user, 0, sizeof(slurmdb_user_rec_t));
- user.uid = *uid;
- if (assoc_mgr_fill_in_user(
- slurmdbd_conn->db_conn, &user, 1, NULL)
- != SLURM_SUCCESS) {
- comment = "Your user has not been added to the accounting system yet.";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- if (!user.coord_accts || !list_count(user.coord_accts)) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- itr = list_iterator_create(get_msg->acct_list);
- itr2 = list_iterator_create(user.coord_accts);
- while ((acct = list_next(itr))) {
- while ((coord = list_next(itr2))) {
- if (!strcasecmp(coord->name, acct))
- break;
- }
- if (!coord) {
- bad = 1;
- break;
- }
- list_iterator_reset(itr2);
- }
- list_iterator_destroy(itr2);
- list_iterator_destroy(itr);
- if (bad) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- }
- rc = acct_storage_g_add_coord(slurmdbd_conn->db_conn, *uid,
- get_msg->acct_list, get_msg->cond);
- end_it:
- slurmdbd_free_acct_coord_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_ACCOUNT_COORDS);
- return rc;
- }
- static int _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_ASSOCS: called");
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_ASSOCS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_ASSOCS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- ListIterator itr = NULL;
- ListIterator itr2 = NULL;
- slurmdb_user_rec_t user;
- slurmdb_coord_rec_t *coord = NULL;
- slurmdb_association_rec_t *object = NULL;
- memset(&user, 0, sizeof(slurmdb_user_rec_t));
- user.uid = *uid;
- if (assoc_mgr_fill_in_user(
- slurmdbd_conn->db_conn, &user, 1, NULL)
- != SLURM_SUCCESS) {
- comment = "Your user has not been added to the accounting system yet.";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- if (!user.coord_accts || !list_count(user.coord_accts)) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- itr = list_iterator_create(get_msg->my_list);
- itr2 = list_iterator_create(user.coord_accts);
- while ((object = list_next(itr))) {
- char *account = "root";
- if (object->user)
- account = object->acct;
- else if (object->parent_acct)
- account = object->parent_acct;
- list_iterator_reset(itr2);
- while ((coord = list_next(itr2))) {
- if (!strcasecmp(coord->name, account))
- break;
- }
- if (!coord)
- break;
- }
- list_iterator_destroy(itr2);
- list_iterator_destroy(itr);
- if (!coord) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- }
- rc = acct_storage_g_add_associations(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_ASSOCS);
- return rc;
- }
- static int _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_CLUSTERS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_CLUSTERS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_CLUSTERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_add_clusters(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- if (rc != SLURM_SUCCESS)
- comment = "Failed to add cluster.";
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_CLUSTERS);
- return rc;
- }
- static int _add_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_QOS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && (assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER)) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_QOS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_QOS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_add_qos(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- if (rc != SLURM_SUCCESS)
- comment = "Failed to add qos.";
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_QOS);
- return rc;
- }
- static int _add_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_USERS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- slurmdb_user_rec_t user;
- memset(&user, 0, sizeof(slurmdb_user_rec_t));
- user.uid = *uid;
- if (assoc_mgr_fill_in_user(
- slurmdbd_conn->db_conn, &user, 1, NULL)
- != SLURM_SUCCESS) {
- comment = "Your user has not been added to the accounting system yet.";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- if (!user.coord_accts || !list_count(user.coord_accts)) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- /* If the user is a coord of any acct they can add
- * users they are only able to make associations to
- * these users if they are coordinators of the
- * account they are trying to add to
- */
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_USERS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_USERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_add_users(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_USERS);
- return rc;
- }
- static int _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_list_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_ADD_WCKEYS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_WCKEYS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_WCKEYS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_add_wckeys(slurmdbd_conn->db_conn, *uid,
- get_msg->my_list);
- end_it:
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_WCKEYS);
- return rc;
- }
- static int _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_rec_msg_t *rec_msg = NULL;
- char *comment = NULL;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)) {
- comment = "DBD_ADD_RESV message from invalid uid";
- error("DBD_ADD_RESV message from invalid uid %u", *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_rec_msg(&rec_msg, slurmdbd_conn->rpc_version,
- DBD_ADD_RESV, in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ADD_RESV message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_ADD_RESV: called");
- rc = acct_storage_g_add_reservation(slurmdbd_conn->db_conn,
- rec_msg->rec);
- end_it:
- slurmdbd_free_rec_msg(rec_msg, DBD_ADD_RESV);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ADD_RESV);
- return rc;
- }
- static int _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- char *comment = "SUCCESS";
- slurmdb_archive_cond_t *arch_cond = NULL;
- debug2("DBD_ARCHIVE_DUMP: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_ARCHIVE_DUMP, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ARCHIVE_DUMP message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- arch_cond = (slurmdb_archive_cond_t *)get_msg->cond;
- /* set up some defaults */
- if (!arch_cond->archive_dir)
- arch_cond->archive_dir = xstrdup(slurmdbd_conf->archive_dir);
- if (!arch_cond->archive_script)
- arch_cond->archive_script =
- xstrdup(slurmdbd_conf->archive_script);
- if (arch_cond->purge_event == NO_VAL)
- arch_cond->purge_event = slurmdbd_conf->purge_event;
- if (arch_cond->purge_job == NO_VAL)
- arch_cond->purge_job = slurmdbd_conf->purge_job;
- if (arch_cond->purge_step == NO_VAL)
- arch_cond->purge_step = slurmdbd_conf->purge_step;
- if (arch_cond->purge_suspend == NO_VAL)
- arch_cond->purge_suspend = slurmdbd_conf->purge_suspend;
- rc = jobacct_storage_g_archive(slurmdbd_conn->db_conn, arch_cond);
- if (rc != SLURM_SUCCESS) {
- if (errno == EACCES)
- comment = "Problem accessing file.";
- else
- comment = "Error with request.";
- }
- end_it:
- slurmdbd_free_cond_msg(get_msg, DBD_ARCHIVE_DUMP);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ARCHIVE_DUMP);
- return rc;
- }
- static int _archive_load(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- slurmdb_archive_rec_t *arch_rec = NULL;
- char *comment = "SUCCESS";
- debug2("DBD_ARCHIVE_LOAD: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdb_unpack_archive_rec((void *)&arch_rec,
- slurmdbd_conn->rpc_version,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ARCHIVE_LOAD message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = jobacct_storage_g_archive_load(slurmdbd_conn->db_conn, arch_rec);
- if (rc == ENOENT)
- comment = "No archive file given to recover.";
- else if (rc != SLURM_SUCCESS)
- comment = "Error with request.";
- end_it:
- slurmdb_destroy_archive_rec(arch_rec);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ARCHIVE_LOAD);
- return rc;
- }
- static int _cluster_cpus(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cluster_cpus_msg_t *cluster_cpus_msg = NULL;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)) {
- comment = "DBD_CLUSTER_CPUS message from invalid uid";
- error("DBD_CLUSTER_CPUS message from invalid uid %u", *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_cluster_cpus_msg(&cluster_cpus_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_CLUSTER_CPUS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_CLUSTER_CPUS: called for %s(%u)",
- slurmdbd_conn->cluster_name,
- cluster_cpus_msg->cpu_count);
- rc = clusteracct_storage_g_cluster_cpus(
- slurmdbd_conn->db_conn,
- cluster_cpus_msg->cluster_nodes,
- cluster_cpus_msg->cpu_count,
- cluster_cpus_msg->event_time);
- if (rc == ESLURM_ACCESS_DENIED) {
- comment = "This cluster hasn't been added to accounting yet";
- rc = SLURM_ERROR;
- }
- end_it:
- if (rc == SLURM_SUCCESS)
- slurmdbd_conn->cluster_cpus = cluster_cpus_msg->cpu_count;
- if (!slurmdbd_conn->ctld_port) {
- info("DBD_CLUSTER_CPUS: cluster not registered");
- slurmdbd_conn->ctld_port =
- clusteracct_storage_g_register_disconn_ctld(
- slurmdbd_conn->db_conn, slurmdbd_conn->ip);
- }
- slurmdbd_free_cluster_cpus_msg(cluster_cpus_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_CLUSTER_CPUS);
- return rc;
- }
- static int _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_ACCOUNTS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_ACCOUNTS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_ACCOUNTS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_ACCOUNTS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_accounts(slurmdbd_conn->db_conn,
- *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_ACCOUNTS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_ACCOUNTS,
- *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_ACCOUNTS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_ACCOUNTS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_ASSOCS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_ASSOCS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_ASSOCS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_ASSOCS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_associations(
- slurmdbd_conn->db_conn, *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_ASSOCS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_ASSOCS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_ASSOCS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_ASSOCS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_CLUSTERS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_CLUSTERS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_CLUSTERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_CLUSTERS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_clusters(
- slurmdbd_conn->db_conn, *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_CLUSTERS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_CLUSTERS,
- *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_CLUSTERS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_CLUSTERS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _unpack_config_name(char **object, Buf buffer)
- {
- char *config_name;
- uint32_t uint32_tmp;
- safe_unpackstr_xmalloc(&config_name, &uint32_tmp, buffer);
- *object = config_name;
- return SLURM_SUCCESS;
- unpack_error:
- *object = NULL;
- return SLURM_ERROR;
- }
- static int _get_config(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- char *config_name = NULL;
- dbd_list_msg_t list_msg = { NULL };
- debug2("DBD_GET_CONFIG: called");
- if (slurmdbd_conn->rpc_version >= 10 &&
- _unpack_config_name(&config_name, in_buffer) != SLURM_SUCCESS) {
- char *comment = "Failed to unpack DBD_GET_CONFIG message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_CONFIG);
- return SLURM_ERROR;
- }
- if (config_name == NULL ||
- strcmp(config_name, "slurmdbd.conf") == 0)
- list_msg.my_list = dump_config();
- else if ((list_msg.my_list = acct_storage_g_get_config(
- slurmdbd_conn->db_conn, config_name)) == NULL) {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_CONFIG);
- xfree(config_name);
- return SLURM_ERROR;
- }
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_CONFIG, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_CONFIG, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- xfree(config_name);
- return SLURM_SUCCESS;
- }
- static int _get_events(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_EVENTS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_EVENTS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_EVENTS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_EVENTS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_events(
- slurmdbd_conn->db_conn, *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_EVENTS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_EVENTS,
- *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_EVENTS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_EVENTS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *cond_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_JOBS_COND: called");
- if (slurmdbd_unpack_cond_msg(&cond_msg, slurmdbd_conn->rpc_version,
- DBD_GET_JOBS_COND, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_JOBS_COND message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_JOBS_COND);
- return SLURM_ERROR;
- }
- list_msg.my_list = jobacct_storage_g_get_jobs_cond(
- slurmdbd_conn->db_conn, *uid, cond_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_JOBS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_JOBS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_JOBS_COND);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(cond_msg, DBD_GET_JOBS_COND);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_probs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_PROBS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_GET_PROBS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_PROBS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_PROBS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_PROBS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_problems(
- slurmdbd_conn->db_conn, *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_PROBS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_PROBS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_PROBS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_PROBS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *cond_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_QOS: called");
- if (slurmdbd_unpack_cond_msg(&cond_msg, slurmdbd_conn->rpc_version,
- DBD_GET_QOS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_QOS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_QOS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_qos(slurmdbd_conn->db_conn, *uid,
- cond_msg->cond);
- if (errno == ESLURM_ACCESS_DENIED && !list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_QOS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_QOS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_QOS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(cond_msg, DBD_GET_QOS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_txn(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *cond_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_TXN: called");
- if (slurmdbd_unpack_cond_msg(&cond_msg, slurmdbd_conn->rpc_version,
- DBD_GET_TXN, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_TXN message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_TXN);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_txn(slurmdbd_conn->db_conn, *uid,
- cond_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_TXN, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_TXN, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_TXN);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(cond_msg, DBD_GET_TXN);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_usage(uint16_t type, slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_usage_msg_t *get_msg = NULL;
- dbd_usage_msg_t got_msg;
- uint16_t ret_type = 0;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- info("DBD_GET_USAGE: called type is %s",
- slurmdbd_msg_type_2_str(type, 1));
- if (slurmdbd_unpack_usage_msg(&get_msg, slurmdbd_conn->rpc_version,
- type, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_USAGE message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment, type);
- return SLURM_ERROR;
- }
- switch(type) {
- case DBD_GET_ASSOC_USAGE:
- ret_type = DBD_GOT_ASSOC_USAGE;
- break;
- case DBD_GET_WCKEY_USAGE:
- ret_type = DBD_GOT_WCKEY_USAGE;
- break;
- case DBD_GET_CLUSTER_USAGE:
- ret_type = DBD_GOT_CLUSTER_USAGE;
- break;
- default:
- comment = "Unknown type of usage to get";
- error("%s %u", comment, type);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment, type);
- return SLURM_ERROR;
- }
- rc = acct_storage_g_get_usage(slurmdbd_conn->db_conn,
- *uid, get_msg->rec, type,
- get_msg->start, get_msg->end);
- slurmdbd_free_usage_msg(get_msg, type);
- if (rc != SLURM_SUCCESS) {
- comment = "Problem getting usage info";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, type);
- return rc;
- }
- memset(&got_msg, 0, sizeof(dbd_usage_msg_t));
- got_msg.rec = get_msg->rec;
- get_msg->rec = NULL;
- *out_buffer = init_buf(1024);
- pack16((uint16_t) ret_type, *out_buffer);
- slurmdbd_pack_usage_msg(&got_msg, slurmdbd_conn->rpc_version,
- ret_type, *out_buffer);
- return SLURM_SUCCESS;
- }
- static int _get_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- slurmdb_user_cond_t * user_cond = NULL;
- debug2("DBD_GET_USERS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_USERS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_USERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_USERS);
- return SLURM_ERROR;
- }
- user_cond = get_msg->cond;
- if ((!user_cond->with_assocs && !user_cond->with_wckeys)
- && ((slurmdbd_conn->rpc_version < 8)
- || (user_cond->assoc_cond->only_defs))) {
- List cluster_list = user_cond->assoc_cond->cluster_list;
- /* load up with just this cluster to query against
- * since befor 2.2 we had only 1 default account so
- * send the default for this cluster. */
- if (!cluster_list) {
- cluster_list = list_create(NULL);
- list_append(cluster_list, slurmdbd_conn->cluster_name);
- user_cond->assoc_cond->cluster_list = cluster_list;
- }
- }
- list_msg.my_list = acct_storage_g_get_users(slurmdbd_conn->db_conn,
- *uid, user_cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_USERS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_USERS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_USERS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_USERS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_WCKEYS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED, comment,
- DBD_GET_WCKEYS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_WCKEYS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_WCKEYS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_WCKEYS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_wckeys(slurmdbd_conn->db_conn,
- *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_WCKEYS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_WCKEYS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_WCKEYS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_WCKEYS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- debug2("DBD_GET_RESVS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_GET_RESVS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_GET_RESVS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_GET_RESVS);
- return SLURM_ERROR;
- }
- list_msg.my_list = acct_storage_g_get_reservations(
- slurmdbd_conn->db_conn, *uid, get_msg->cond);
- if (!errno) {
- if (!list_msg.my_list)
- list_msg.my_list = list_create(NULL);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_RESVS, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_RESVS, *out_buffer);
- } else {
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- errno, slurm_strerror(errno),
- DBD_GET_RESVS);
- rc = SLURM_ERROR;
- }
- slurmdbd_free_cond_msg(get_msg, DBD_GET_RESVS);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_cluster_cpus_msg_t *cluster_cpus_msg = NULL;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)) {
- comment = "DBD_FLUSH_JOBS message from invalid uid";
- error("DBD_FLUSH_JOBS message from invalid uid %u", *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_cluster_cpus_msg(
- &cluster_cpus_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_FLUSH_JOBS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_FLUSH_JOBS: called for %s",
- slurmdbd_conn->cluster_name);
- rc = acct_storage_g_flush_jobs_on_cluster(
- slurmdbd_conn->db_conn,
- cluster_cpus_msg->event_time);
- end_it:
- slurmdbd_free_cluster_cpus_msg(cluster_cpus_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_FLUSH_JOBS);
- return rc;
- }
- static int _init_conn(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_init_msg_t *init_msg = NULL;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- if ((rc = slurmdbd_unpack_init_msg(&init_msg, in_buffer,
- slurmdbd_conf->auth_info))
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_INIT message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- goto end_it;
- }
- if ((init_msg->version < SLURMDBD_VERSION_MIN) ||
- (init_msg->version > SLURMDBD_VERSION)) {
- comment = "Incompatible RPC version";
- error("Incompatible RPC version received "
- "(%u not between %d and %d)",
- init_msg->version,
- SLURMDBD_VERSION_MIN, SLURMDBD_VERSION);
- rc = SLURM_PROTOCOL_VERSION_ERROR;
- goto end_it;
- }
- *uid = init_msg->uid;
- debug("DBD_INIT: CLUSTER:%s VERSION:%u UID:%u IP:%s CONN:%u",
- init_msg->cluster_name, init_msg->version, init_msg->uid,
- slurmdbd_conn->ip, slurmdbd_conn->newsockfd);
- slurmdbd_conn->cluster_name = xstrdup(init_msg->cluster_name);
- slurmdbd_conn->db_conn = acct_storage_g_get_connection(
- false, slurmdbd_conn->newsockfd, init_msg->rollback,
- slurmdbd_conn->cluster_name);
- slurmdbd_conn->rpc_version = init_msg->version;
- if (errno) {
- rc = errno;
- comment = slurm_strerror(rc);
- }
- end_it:
- slurmdbd_free_init_msg(init_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_INIT);
- return rc;
- }
- static int _fini_conn(slurmdbd_conn_t *slurmdbd_conn, Buf in_buffer,
- Buf *out_buffer)
- {
- dbd_fini_msg_t *fini_msg = NULL;
- char *comment = NULL;
- int rc = SLURM_SUCCESS;
- if (slurmdbd_unpack_fini_msg(
- &fini_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_FINI message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_FINI: CLOSE:%u COMMIT:%u",
- fini_msg->close_conn, fini_msg->commit);
- if (fini_msg->close_conn == 1)
- rc = acct_storage_g_close_connection(&slurmdbd_conn->db_conn);
- else
- rc = acct_storage_g_commit(slurmdbd_conn->db_conn,
- fini_msg->commit);
- end_it:
- slurmdbd_free_fini_msg(fini_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_FINI);
- return rc;
- }
- static int _job_complete(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_job_comp_msg_t *job_comp_msg = NULL;
- struct job_record job;
- struct job_details details;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_JOB_COMPLETE message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_job_complete_msg(
- &job_comp_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_JOB_COMPLETE message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- memset(&job, 0, sizeof(struct job_record));
- memset(&details, 0, sizeof(struct job_details));
- job.assoc_id = job_comp_msg->assoc_id;
- job.comment = job_comp_msg->comment;
- if (job_comp_msg->db_index != NO_VAL)
- job.db_index = job_comp_msg->db_index;
- job.derived_ec = job_comp_msg->derived_ec;
- job.end_time = job_comp_msg->end_time;
- job.exit_code = job_comp_msg->exit_code;
- job.job_id = job_comp_msg->job_id;
- job.job_state = job_comp_msg->job_state;
- job.requid = job_comp_msg->req_uid;
- job.nodes = job_comp_msg->nodes;
- job.start_time = job_comp_msg->start_time;
- details.submit_time = job_comp_msg->submit_time;
- job.details = &details;
- if (job.job_state & JOB_RESIZING) {
- job.resize_time = job_comp_msg->end_time;
- debug2("DBD_JOB_COMPLETE: RESIZE ID:%u", job_comp_msg->job_id);
- } else
- debug2("DBD_JOB_COMPLETE: ID:%u", job_comp_msg->job_id);
- rc = jobacct_storage_g_job_complete(slurmdbd_conn->db_conn, &job);
- if (rc && errno == 740) /* meaning data is already there */
- rc = SLURM_SUCCESS;
- /* just incase this gets set we need to clear it */
- xfree(job.wckey);
- if (!slurmdbd_conn->ctld_port) {
- info("DBD_JOB_COMPLETE: cluster not registered");
- slurmdbd_conn->ctld_port =
- clusteracct_storage_g_register_disconn_ctld(
- slurmdbd_conn->db_conn, slurmdbd_conn->ip);
- }
- end_it:
- slurmdbd_free_job_complete_msg(job_comp_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_JOB_COMPLETE);
- return SLURM_SUCCESS;
- }
- static int _job_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_job_start_msg_t *job_start_msg = NULL;
- dbd_id_rc_msg_t id_rc_msg;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_JOB_START message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED, comment,
- DBD_JOB_START);
- return SLURM_ERROR;
- }
- if (slurmdbd_unpack_job_start_msg((void **)&job_start_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_JOB_START message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_JOB_START);
- return SLURM_ERROR;
- }
- _process_job_start(slurmdbd_conn, job_start_msg, &id_rc_msg);
- slurmdbd_free_job_start_msg(job_start_msg);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_ID_RC, *out_buffer);
- slurmdbd_pack_id_rc_msg(&id_rc_msg,
- slurmdbd_conn->rpc_version, *out_buffer);
- return SLURM_SUCCESS;
- }
- static int _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_job_suspend_msg_t *job_suspend_msg = NULL;
- struct job_record job;
- struct job_details details;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_JOB_SUSPEND message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_job_suspend_msg(&job_suspend_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_JOB_SUSPEND message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_JOB_SUSPEND: ID:%u STATE:%s",
- job_suspend_msg->job_id,
- job_state_string((enum job_states) job_suspend_msg->job_state));
- memset(&job, 0, sizeof(struct job_record));
- memset(&details, 0, sizeof(struct job_details));
- job.assoc_id = job_suspend_msg->assoc_id;
- if (job_suspend_msg->db_index != NO_VAL)
- job.db_index = job_suspend_msg->db_index;
- job.job_id = job_suspend_msg->job_id;
- job.job_state = job_suspend_msg->job_state;
- details.submit_time = job_suspend_msg->submit_time;
- job.suspend_time = job_suspend_msg->suspend_time;
- job.details = &details;
- rc = jobacct_storage_g_job_suspend(slurmdbd_conn->db_conn, &job);
- if (rc && errno == 740) /* meaning data is already there */
- rc = SLURM_SUCCESS;
- /* just incase this gets set we need to clear it */
- xfree(job.wckey);
- end_it:
- slurmdbd_free_job_suspend_msg(job_suspend_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_JOB_SUSPEND);
- return SLURM_SUCCESS;
- }
- static int _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_ACCOUNTS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_ACCOUNTS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_ACCOUNTS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_ACCOUNTS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_ACCOUNTS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_accounts(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_ACCOUNTS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_ACCOUNTS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_ACCOUNTS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_ASSOCS: called");
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_ASSOCS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_ASSOCS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_ASSOCS);
- return SLURM_ERROR;
- }
- /* All authentication needs to be done inside the plugin since we are
- * unable to know what accounts this request is talking about
- * until we process it through the database.
- */
- if (!(list_msg.my_list = acct_storage_g_modify_associations(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_ASSOCS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_ASSOCS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_ASSOCS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_CLUSTERS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_CLUSTERS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_CLUSTERS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_CLUSTERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_CLUSTERS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_clusters(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_CLUSTERS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_CLUSTERS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_CLUSTERS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_job(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_JOB: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_JOB);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_JOB,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_JOB message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_JOB);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_job(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_JOB);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_JOB);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_JOB);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_QOS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_QOS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_QOS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_QOS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_QOS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_qos(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_QOS_PREEMPTION_LOOP) {
- comment = "QOS Preemption loop detected";
- rc = ESLURM_QOS_PREEMPTION_LOOP;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_QOS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_QOS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_QOS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- int same_user = 0;
- int admin_level = assoc_mgr_get_admin_level(slurmdbd_conn->db_conn,
- *uid);
- slurmdb_user_cond_t *user_cond = NULL;
- slurmdb_user_rec_t *user_rec = NULL;
- debug2("DBD_MODIFY_USERS: called");
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_USERS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_USERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_USERS);
- return SLURM_ERROR;
- }
- user_cond = (slurmdb_user_cond_t *)get_msg->cond;
- user_rec = (slurmdb_user_rec_t *)get_msg->rec;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && admin_level < SLURMDB_ADMIN_OPERATOR) {
- if (user_cond && user_cond->assoc_cond
- && user_cond->assoc_cond->user_list
- && (list_count(user_cond->assoc_cond->user_list) == 1)) {
- uid_t pw_uid;
- char *name;
- name = list_peek (user_cond->assoc_cond->user_list);
- if ((uid_from_string (name, &pw_uid) >= 0)
- && pw_uid == *uid) {
- same_user = 1;
- goto is_same_user;
- }
- }
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_USERS);
- return ESLURM_ACCESS_DENIED;
- }
- is_same_user:
- /* same_user can only alter the default account, default wckey
- * nothing else */
- if (same_user) {
- /* If we add anything else here for the user we will
- * need to document it
- */
- if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET)) {
- comment = "You can only change your own default account, default wckey nothing else";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->
- rpc_version,
- ESLURM_ACCESS_DENIED,
- comment,
- DBD_MODIFY_USERS);
- return ESLURM_ACCESS_DENIED;
- }
- }
- if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET)
- && (*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && (admin_level < user_rec->admin_level)) {
- comment = "You have to be the same or higher admin level to change another persons";
- user_rec->admin_level = SLURMDB_ADMIN_NOTSET;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_users(
- slurmdbd_conn->db_conn, *uid, user_cond, user_rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_USERS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_USERS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_USERS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_list_msg_t list_msg;
- int rc = SLURM_SUCCESS;
- dbd_modify_msg_t *get_msg = NULL;
- char *comment = NULL;
- debug2("DBD_MODIFY_WCKEYS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_MODIFY_WCKEYS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_modify_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_WCKEYS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_WCKEYS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_MODIFY_WCKEYS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_modify_wckeys(
- slurmdbd_conn->db_conn, *uid, get_msg->cond,
- get_msg->rec))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_WCKEYS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_WCKEYS);
- return rc;
- }
- slurmdbd_free_modify_msg(get_msg, DBD_MODIFY_WCKEYS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_rec_msg_t *rec_msg = NULL;
- char *comment = NULL;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)) {
- comment = "DBD_MODIFY_RESV message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_rec_msg(&rec_msg, slurmdbd_conn->rpc_version,
- DBD_MODIFY_RESV, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_MODIFY_RESV message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_MODIFY_RESV: called");
- rc = acct_storage_g_modify_reservation(slurmdbd_conn->db_conn,
- rec_msg->rec);
- end_it:
- slurmdbd_free_rec_msg(rec_msg, DBD_MODIFY_RESV);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_MODIFY_RESV);
- return rc;
- }
- static int _node_state(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_node_state_msg_t *node_state_msg = NULL;
- struct node_record node_ptr;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_NODE_STATE message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_node_state_msg(&node_state_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_NODE_STATE message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- memset(&node_ptr, 0, sizeof(struct node_record));
- node_ptr.name = node_state_msg->hostlist;
- node_ptr.cpus = node_state_msg->cpu_count;
- node_ptr.node_state = node_state_msg->state;
- node_ptr.reason = node_state_msg->reason;
- node_ptr.reason_time = node_state_msg->event_time;
- node_ptr.reason_uid = node_state_msg->reason_uid;
- slurmctld_conf.fast_schedule = 0;
- if (!node_ptr.cpus)
- node_state_msg->new_state = DBD_NODE_STATE_UP;
- if (node_state_msg->new_state == DBD_NODE_STATE_UP) {
- debug3("DBD_NODE_STATE: NODE:%s STATE:%s REASON:%s TIME:%ld",
- node_state_msg->hostlist,
- _node_state_string(node_state_msg->new_state),
- node_state_msg->reason,
- (long)node_state_msg->event_time);
- rc = clusteracct_storage_g_node_up(
- slurmdbd_conn->db_conn,
- &node_ptr,
- node_state_msg->event_time);
- } else {
- debug2("DBD_NODE_STATE: NODE:%s STATE:%s "
- "REASON:%s UID:%u TIME:%ld",
- node_state_msg->hostlist,
- _node_state_string(node_state_msg->new_state),
- node_state_msg->reason,
- node_ptr.reason_uid,
- (long)node_state_msg->event_time);
- rc = clusteracct_storage_g_node_down(
- slurmdbd_conn->db_conn,
- &node_ptr,
- node_state_msg->event_time,
- node_state_msg->reason, node_ptr.reason_uid);
- }
- end_it:
- slurmdbd_free_node_state_msg(node_state_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_NODE_STATE);
- return SLURM_SUCCESS;
- }
- static char *_node_state_string(uint16_t node_state)
- {
- switch(node_state) {
- case DBD_NODE_STATE_DOWN:
- return "DOWN";
- case DBD_NODE_STATE_UP:
- return "UP";
- }
- return "UNKNOWN";
- }
- static void _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
- dbd_job_start_msg_t *job_start_msg,
- dbd_id_rc_msg_t *id_rc_msg)
- {
- struct job_record job, *job_ptr;
- struct job_details details;
- memset(&job, 0, sizeof(struct job_record));
- memset(&details, 0, sizeof(struct job_details));
- memset(id_rc_msg, 0, sizeof(dbd_id_rc_msg_t));
- job.total_cpus = job_start_msg->alloc_cpus;
- job.total_nodes = job_start_msg->alloc_nodes;
- job.account = _replace_double_quotes(job_start_msg->account);
- job.assoc_id = job_start_msg->assoc_id;
- job.comment = job_start_msg->block_id;
- if (job_start_msg->db_index != NO_VAL)
- job.db_index = job_start_msg->db_index;
- details.begin_time = job_start_msg->eligible_time;
- job.user_id = job_start_msg->uid;
- job.group_id = job_start_msg->gid;
- job.job_id = job_start_msg->job_id;
- job.job_state = job_start_msg->job_state;
- job.name = _replace_double_quotes(job_start_msg->name);
- job.nodes = job_start_msg->nodes;
- job.network = job_start_msg->node_inx;
- job.partition = job_start_msg->partition;
- details.min_cpus = job_start_msg->req_cpus;
- job.qos_id = job_start_msg->qos_id;
- job.resv_id = job_start_msg->resv_id;
- job.priority = job_start_msg->priority;
- job.start_time = job_start_msg->start_time;
- job.time_limit = job_start_msg->timelimit;
- job.gres_alloc = job_start_msg->gres_alloc;
- job.gres_req = job_start_msg->gres_req;
- job.gres_used = job_start_msg->gres_used;
- job.wckey = _replace_double_quotes(job_start_msg->wckey);
- details.submit_time = job_start_msg->submit_time;
- job.details = &details;
- job_ptr = &job;
- if (job.job_state & JOB_RESIZING) {
- job.resize_time = job_start_msg->eligible_time;
- debug2("DBD_JOB_START: RESIZE CALL ID:%u NAME:%s INX:%u",
- job_start_msg->job_id, job_start_msg->name,
- job.db_index);
- } else if (job.start_time && !IS_JOB_PENDING(job_ptr)) {
- debug2("DBD_JOB_START: START CALL ID:%u NAME:%s INX:%u",
- job_start_msg->job_id, job_start_msg->name,
- job.db_index);
- } else {
- debug2("DBD_JOB_START: ELIGIBLE CALL ID:%u NAME:%s",
- job_start_msg->job_id, job_start_msg->name);
- }
- id_rc_msg->return_code = jobacct_storage_g_job_start(
- slurmdbd_conn->db_conn, &job);
- id_rc_msg->job_id = job.job_id;
- id_rc_msg->id = job.db_index;
- /* just incase job.wckey was set because we didn't send one */
- if (!job_start_msg->wckey)
- xfree(job.wckey);
- if (!slurmdbd_conn->ctld_port) {
- info("DBD_JOB_START: cluster not registered");
- slurmdbd_conn->ctld_port =
- clusteracct_storage_g_register_disconn_ctld(
- slurmdbd_conn->db_conn, slurmdbd_conn->ip);
- }
- }
- static int _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_register_ctld_msg_t *register_ctld_msg = NULL;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- slurmdb_cluster_cond_t cluster_q;
- slurmdb_cluster_rec_t cluster;
- dbd_list_msg_t list_msg;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_REGISTER_CTLD message from invalid uid";
- error("CONN:%u %s %u",
- slurmdbd_conn->newsockfd, comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_register_ctld_msg(®ister_ctld_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REGISTER_CTLD message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_REGISTER_CTLD: called for %s(%u)",
- slurmdbd_conn->cluster_name, register_ctld_msg->port);
- debug2("slurmctld at ip:%s, port:%d",
- slurmdbd_conn->ip, register_ctld_msg->port);
- slurmdb_init_cluster_cond(&cluster_q, 0);
- slurmdb_init_cluster_rec(&cluster, 0);
- cluster_q.cluster_list = list_create(NULL);
- list_append(cluster_q.cluster_list, slurmdbd_conn->cluster_name);
- cluster.control_host = slurmdbd_conn->ip;
- cluster.control_port = register_ctld_msg->port;
- cluster.dimensions = register_ctld_msg->dimensions;
- cluster.flags = register_ctld_msg->flags;
- cluster.plugin_id_select = register_ctld_msg->plugin_id_select;
- cluster.rpc_version = slurmdbd_conn->rpc_version;
- list_msg.my_list = acct_storage_g_modify_clusters(
- slurmdbd_conn->db_conn, *uid, &cluster_q, &cluster);
- if (errno == EFAULT) {
- comment = "Request to register was incomplete";
- rc = SLURM_ERROR;
- } else if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else if (!list_msg.my_list || !list_count(list_msg.my_list)) {
- comment = "This cluster hasn't been added to accounting yet";
- rc = SLURM_ERROR;
- }
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- list_destroy(cluster_q.cluster_list);
- /*
- * Outgoing message header must have flag set:
- * out_msg.flags = SLURM_GLOBAL_AUTH_KEY;
- */
- #if 0
- {
- /* Code to validate communications back to slurmctld */
- slurm_fd_t fd;
- slurm_set_addr_char(&ctld_address, register_ctld_msg->port, ip);
- fd = slurm_open_msg_conn(&ctld_address);
- if (fd < 0) {
- error("CONN: can not open socket back to slurmctld",
- slurmdbd_conn->newsockfd);
- } else {
- slurm_msg_t out_msg;
- slurm_msg_t_init(&out_msg);
- out_msg.msg_type = REQUEST_PING;
- out_msg.flags = SLURM_GLOBAL_AUTH_KEY;
- slurm_send_node_msg(slurmdbd_conn->rpc_version,
- fd, &out_msg);
- /* We probably need to add matching recv_msg function
- * for an arbitray fd or should these be fire
- * and forget? */
- slurm_close_stream(fd);
- }
- }
- #endif
- end_it:
- if (rc == SLURM_SUCCESS)
- slurmdbd_conn->ctld_port = register_ctld_msg->port;
- slurmdbd_free_register_ctld_msg(register_ctld_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REGISTER_CTLD);
- return rc;
- }
- static int _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_ACCOUNTS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_REMOVE_ACCOUNTS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_ACCOUNTS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_ACCOUNTS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_ACCOUNTS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_remove_accounts(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_ACCOUNTS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_ACCOUNTS);
- return rc;
- }
- list_msg.return_code = errno;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_ACCOUNTS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_acct_coord_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_ACCOUNT_COORDS: called");
- if (slurmdbd_unpack_acct_coord_msg(
- &get_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_ACCOUNT_COORDS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_ADD_ACCOUNT_COORDS);
- return SLURM_ERROR;
- }
- /* All authentication needs to be done inside the plugin since we are
- * unable to know what accounts this request is talking about
- * until we process it through the database.
- */
- if (!(list_msg.my_list = acct_storage_g_remove_coord(
- slurmdbd_conn->db_conn, *uid, get_msg->acct_list,
- get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_acct_coord_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment,
- DBD_REMOVE_ACCOUNT_COORDS);
- return rc;
- }
- list_msg.return_code = SLURM_SUCCESS;
- slurmdbd_free_acct_coord_msg(get_msg);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_ASSOCS: called");
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_ASSOCS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_ASSOCS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_ASSOCS);
- return SLURM_ERROR;
- }
- /* All authentication needs to be done inside the plugin since we are
- * unable to know what accounts this request is talking about
- * until we process it through the database.
- */
- if (!(list_msg.my_list = acct_storage_g_remove_associations(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_ASSOCS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_ASSOCS);
- return rc;
- }
- list_msg.return_code = errno;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_ASSOCS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_CLUSTERS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_REMOVE_CLUSTERS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_CLUSTERS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_CLUSTERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_CLUSTERS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_remove_clusters(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_CLUSTERS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_CLUSTERS);
- return rc;
- }
- list_msg.return_code = errno;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_CLUSTERS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_QOS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_REMOVE_QOS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_QOS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_QOS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_QOS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_remove_qos(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_QOS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_QOS);
- return rc;
- }
- list_msg.return_code = SLURM_SUCCESS;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_QOS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_users(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_USERS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_REMOVE_USERS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_USERS, in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_USERS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_USERS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_remove_users(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_USERS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_USERS);
- return rc;
- }
- list_msg.return_code = errno;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_USERS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_cond_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- debug2("DBD_REMOVE_WCKEYS: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_SUPER_USER) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED,
- comment, DBD_REMOVE_WCKEYS);
- return ESLURM_ACCESS_DENIED;
- }
- if (slurmdbd_unpack_cond_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_WCKEYS,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_WCKEYS message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR,
- comment, DBD_REMOVE_WCKEYS);
- return SLURM_ERROR;
- }
- if (!(list_msg.my_list = acct_storage_g_remove_wckeys(
- slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
- if (errno == ESLURM_ACCESS_DENIED) {
- comment = "Your user doesn't have privilege to preform this action";
- rc = ESLURM_ACCESS_DENIED;
- } else if (errno == SLURM_ERROR) {
- comment = "Something was wrong with your query";
- rc = SLURM_ERROR;
- } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
- comment = "Request didn't affect anything";
- rc = SLURM_SUCCESS;
- } else if (errno == ESLURM_DB_CONNECTION) {
- comment = slurm_strerror(errno);
- rc = errno;
- } else {
- rc = errno;
- if (!(comment = slurm_strerror(errno)))
- comment = "Unknown issue";
- }
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_WCKEYS);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_WCKEYS);
- return rc;
- }
- list_msg.return_code = SLURM_SUCCESS;
- slurmdbd_free_cond_msg(get_msg, DBD_REMOVE_WCKEYS);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_LIST, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return rc;
- }
- static int _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- int rc = SLURM_SUCCESS;
- dbd_rec_msg_t *rec_msg = NULL;
- char *comment = NULL;
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)) {
- comment = "DBD_REMOVE_RESV message from invalid uid";
- error("DBD_REMOVE_RESV message from invalid uid %u", *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_rec_msg(&rec_msg, slurmdbd_conn->rpc_version,
- DBD_REMOVE_RESV,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_REMOVE_RESV message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_REMOVE_RESV: called");
- rc = acct_storage_g_remove_reservation(slurmdbd_conn->db_conn,
- rec_msg->rec);
- end_it:
- slurmdbd_free_rec_msg(rec_msg, DBD_REMOVE_RESV);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_REMOVE_RESV);
- return rc;
- }
- static int _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_roll_usage_msg_t *get_msg = NULL;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- info("DBD_ROLL_USAGE: called");
- if ((*uid != slurmdbd_conf->slurm_user_id && *uid != 0)
- && assoc_mgr_get_admin_level(slurmdbd_conn->db_conn, *uid)
- < SLURMDB_ADMIN_OPERATOR) {
- comment = "Your user doesn't have privilege to preform this action";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_roll_usage_msg(
- &get_msg, slurmdbd_conn->rpc_version, in_buffer)
- != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_ROLL_USAGE message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- rc = acct_storage_g_roll_usage(slurmdbd_conn->db_conn,
- get_msg->start, get_msg->end,
- get_msg->archive_data);
- end_it:
- slurmdbd_free_roll_usage_msg(get_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_ROLL_USAGE);
- return rc;
- }
- static int _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid)
- {
- dbd_list_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- ListIterator itr = NULL;
- dbd_job_start_msg_t *job_start_msg;
- dbd_id_rc_msg_t *id_rc_msg;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_SEND_MULT_JOB_START message from invalid uid";
- error("%s %u", comment, *uid);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED, comment,
- DBD_SEND_MULT_JOB_START);
- return SLURM_ERROR;
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_SEND_MULT_JOB_START,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_SEND_MULT_JOB_START message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_SEND_MULT_JOB_START);
- return SLURM_ERROR;
- }
- list_msg.my_list = list_create(slurmdbd_free_id_rc_msg);
- itr = list_iterator_create(get_msg->my_list);
- while ((job_start_msg = list_next(itr))) {
- id_rc_msg = xmalloc(sizeof(dbd_id_rc_msg_t));
- list_append(list_msg.my_list, id_rc_msg);
- _process_job_start(slurmdbd_conn, job_start_msg, id_rc_msg);
- }
- list_iterator_destroy(itr);
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_MULT_JOB_START, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_MULT_JOB_START, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return SLURM_SUCCESS;
- }
- static int _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer,
- uint32_t *uid)
- {
- dbd_list_msg_t *get_msg = NULL;
- dbd_list_msg_t list_msg;
- char *comment = NULL;
- ListIterator itr = NULL;
- Buf req_buf = NULL, ret_buf = NULL;
- int rc = SLURM_SUCCESS;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_SEND_MULT_MSG message from invalid uid";
- error("%s %u", comment, *uid);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- ESLURM_ACCESS_DENIED, comment,
- DBD_SEND_MULT_MSG);
- return SLURM_ERROR;
- }
- if (slurmdbd_unpack_list_msg(&get_msg, slurmdbd_conn->rpc_version,
- DBD_SEND_MULT_MSG,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_SEND_MULT_MSG message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- SLURM_ERROR, comment,
- DBD_SEND_MULT_MSG);
- return SLURM_ERROR;
- }
- list_msg.my_list = list_create(slurmdbd_free_buffer);
- itr = list_iterator_create(get_msg->my_list);
- while ((req_buf = list_next(itr))) {
- ret_buf = NULL;
- rc = proc_req(slurmdbd_conn, get_buf_data(req_buf),
- size_buf(req_buf), 0, &ret_buf, uid);
- if (ret_buf)
- list_append(list_msg.my_list, ret_buf);
- if (rc != SLURM_SUCCESS)
- break;
- }
- list_iterator_destroy(itr);
- slurmdbd_free_list_msg(get_msg);
- *out_buffer = init_buf(1024);
- pack16((uint16_t) DBD_GOT_MULT_MSG, *out_buffer);
- slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->rpc_version,
- DBD_GOT_MULT_MSG, *out_buffer);
- if (list_msg.my_list)
- list_destroy(list_msg.my_list);
- return SLURM_SUCCESS;
- }
- static int _step_complete(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_step_comp_msg_t *step_comp_msg = NULL;
- struct step_record step;
- struct job_record job;
- struct job_details details;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_STEP_COMPLETE message from invalid uid";
- error("%s %u", comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_step_complete_msg(&step_comp_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) !=
- SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_STEP_COMPLETE message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_STEP_COMPLETE: ID:%u.%u SUBMIT:%lu",
- step_comp_msg->job_id, step_comp_msg->step_id,
- (unsigned long) step_comp_msg->job_submit_time);
- memset(&step, 0, sizeof(struct step_record));
- memset(&job, 0, sizeof(struct job_record));
- memset(&details, 0, sizeof(struct job_details));
- job.assoc_id = step_comp_msg->assoc_id;
- if (step_comp_msg->db_index != NO_VAL)
- job.db_index = step_comp_msg->db_index;
- job.end_time = step_comp_msg->end_time;
- step.exit_code = step_comp_msg->exit_code;
- step.jobacct = step_comp_msg->jobacct;
- job.job_id = step_comp_msg->job_id;
- step.requid = step_comp_msg->req_uid;
- job.start_time = step_comp_msg->start_time;
- details.submit_time = step_comp_msg->job_submit_time;
- step.step_id = step_comp_msg->step_id;
- step.cpu_count = step_comp_msg->total_cpus;
- details.num_tasks = step_comp_msg->total_tasks;
- job.details = &details;
- step.job_ptr = &job;
- rc = jobacct_storage_g_step_complete(slurmdbd_conn->db_conn, &step);
- if (rc && errno == 740) /* meaning data is already there */
- rc = SLURM_SUCCESS;
- /* just incase this gets set we need to clear it */
- xfree(job.wckey);
- if (!slurmdbd_conn->ctld_port) {
- info("DBD_STEP_COMPLETE: cluster not registered");
- slurmdbd_conn->ctld_port =
- clusteracct_storage_g_register_disconn_ctld(
- slurmdbd_conn->db_conn, slurmdbd_conn->ip);
- }
- end_it:
- slurmdbd_free_step_complete_msg(step_comp_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_STEP_COMPLETE);
- return rc;
- }
- static int _step_start(slurmdbd_conn_t *slurmdbd_conn,
- Buf in_buffer, Buf *out_buffer, uint32_t *uid)
- {
- dbd_step_start_msg_t *step_start_msg = NULL;
- struct step_record step;
- struct job_record job;
- struct job_details details;
- slurm_step_layout_t layout;
- int rc = SLURM_SUCCESS;
- char *comment = NULL;
- if (*uid != slurmdbd_conf->slurm_user_id) {
- comment = "DBD_STEP_START message from invalid uid";
- error("%s %u", comment, *uid);
- rc = ESLURM_ACCESS_DENIED;
- goto end_it;
- }
- if (slurmdbd_unpack_step_start_msg(&step_start_msg,
- slurmdbd_conn->rpc_version,
- in_buffer) != SLURM_SUCCESS) {
- comment = "Failed to unpack DBD_STEP_START message";
- error("CONN:%u %s", slurmdbd_conn->newsockfd, comment);
- rc = SLURM_ERROR;
- goto end_it;
- }
- debug2("DBD_STEP_START: ID:%u.%u NAME:%s SUBMIT:%lu",
- step_start_msg->job_id, step_start_msg->step_id,
- step_start_msg->name,
- (unsigned long) step_start_msg->job_submit_time);
- memset(&step, 0, sizeof(struct step_record));
- memset(&job, 0, sizeof(struct job_record));
- memset(&details, 0, sizeof(struct job_details));
- memset(&layout, 0, sizeof(slurm_step_layout_t));
- job.assoc_id = step_start_msg->assoc_id;
- if (step_start_msg->db_index != NO_VAL)
- job.db_index = step_start_msg->db_index;
- job.job_id = step_start_msg->job_id;
- step.name = step_start_msg->name;
- job.nodes = step_start_msg->nodes;
- step.network = step_start_msg->node_inx;
- step.start_time = step_start_msg->start_time;
- details.submit_time = step_start_msg->job_submit_time;
- step.step_id = step_start_msg->step_id;
- step.cpu_count = step_start_msg->total_cpus;
- details.num_tasks = step_start_msg->total_tasks;
- layout.node_cnt = step_start_msg->node_cnt;
- layout.task_dist = step_start_msg->task_dist;
- job.details = &details;
- step.job_ptr = &job;
- step.step_layout = &layout;
- rc = jobacct_storage_g_step_start(slurmdbd_conn->db_conn, &step);
- if (rc && errno == 740) /* meaning data is already there */
- rc = SLURM_SUCCESS;
- /* just incase this gets set we need to clear it */
- xfree(job.wckey);
- if (!slurmdbd_conn->ctld_port) {
- info("DBD_STEP_START: cluster not registered");
- slurmdbd_conn->ctld_port =
- clusteracct_storage_g_register_disconn_ctld(
- slurmdbd_conn->db_conn, slurmdbd_conn->ip);
- }
- end_it:
- slurmdbd_free_step_start_msg(step_start_msg);
- *out_buffer = make_dbd_rc_msg(slurmdbd_conn->rpc_version,
- rc, comment, DBD_STEP_START);
- return rc;
- }