| /****************************************************************************\ |
| * slurmdbd_defs.c - functions for use with Slurm DBD RPCs |
| ***************************************************************************** |
| * Copyright (C) SchedMD LLC. |
| * Copyright (C) 2008-2010 Lawrence Livermore National Security. |
| * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). |
| * Written by Morris Jette <jette1@llnl.gov> |
| * CODE-OCEC-09-009. All rights reserved. |
| * |
| * This file is part of Slurm, a resource management program. |
| * For details, see <https://slurm.schedmd.com/>. |
| * Please also read the included file: DISCLAIMER. |
| * |
| * Slurm is free software; you can redistribute it and/or modify it under |
| * the terms of the GNU General Public License as published by the Free |
| * Software Foundation; either version 2 of the License, or (at your option) |
| * any later version. |
| * |
| * 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/slurmdbd_defs.h" |
| #include "src/interfaces/jobacct_gather.h" |
| |
| /* |
| * Define slurm-specific aliases for use by plugins, see slurm_xlator.h |
| * for details. |
| */ |
| strong_alias(slurmdbd_free_buffer, slurm_slurmdbd_free_buffer); |
| strong_alias(slurmdbd_free_list_msg, slurm_slurmdbd_free_list_msg); |
| strong_alias(slurmdbd_free_usage_msg, slurm_slurmdbd_free_usage_msg); |
| strong_alias(slurmdbd_free_id_rc_msg, slurm_slurmdbd_free_id_rc_msg); |
| |
| extern slurmdbd_msg_type_t str_2_slurmdbd_msg_type(char *msg_type) |
| { |
| if (!msg_type) { |
| return NO_VAL; |
| } else if (!xstrcasecmp(msg_type, "Fini")) { |
| return DBD_FINI; |
| } else if (!xstrcasecmp(msg_type, "Add Accounts")) { |
| return DBD_ADD_ACCOUNTS; |
| } else if (!xstrcasecmp(msg_type, "Add Accounts Cond")) { |
| return DBD_ADD_ACCOUNTS_COND; |
| } else if (!xstrcasecmp(msg_type, "Add Account Coord")) { |
| return DBD_ADD_ACCOUNT_COORDS; |
| } else if (!xstrcasecmp(msg_type, "Add TRES")) { |
| return DBD_ADD_TRES; |
| } else if (!xstrcasecmp(msg_type, "Add Associations")) { |
| return DBD_ADD_ASSOCS; |
| } else if (!xstrcasecmp(msg_type, "Add Clusters")) { |
| return DBD_ADD_CLUSTERS; |
| } else if (!xstrcasecmp(msg_type, "Add Federations")) { |
| return DBD_ADD_FEDERATIONS; |
| } else if (!xstrcasecmp(msg_type, "Add Resources")) { |
| return DBD_ADD_RES; |
| } else if (!xstrcasecmp(msg_type, "Add Users")) { |
| return DBD_ADD_USERS; |
| } else if (!xstrcasecmp(msg_type, "Add Users Cond")) { |
| return DBD_ADD_USERS_COND; |
| } else if (!xstrcasecmp(msg_type, "Cluster TRES")) { |
| return DBD_CLUSTER_TRES; |
| } else if (!xstrcasecmp(msg_type, "Flush Jobs")) { |
| return DBD_FLUSH_JOBS; |
| } else if (!xstrcasecmp(msg_type, "Get Accounts")) { |
| return DBD_GET_ACCOUNTS; |
| } else if (!xstrcasecmp(msg_type, "Get TRES")) { |
| return DBD_GET_TRES; |
| } else if (!xstrcasecmp(msg_type, "Get Associations")) { |
| return DBD_GET_ASSOCS; |
| } else if (!xstrcasecmp(msg_type, "Get Association Usage")) { |
| return DBD_GET_ASSOC_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Get Clusters")) { |
| return DBD_GET_CLUSTERS; |
| } else if (!xstrcasecmp(msg_type, "Get Cluster Usage")) { |
| return DBD_GET_CLUSTER_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Get Events")) { |
| return DBD_GET_EVENTS; |
| } else if (!xstrcasecmp(msg_type, "Get Federations")) { |
| return DBD_GET_FEDERATIONS; |
| } else if (!xstrcasecmp(msg_type, "Get Instances")) { |
| return DBD_GET_INSTANCES; |
| } else if (!xstrcasecmp(msg_type, "Reconfigure")) { |
| return DBD_RECONFIG; |
| } else if (!xstrcasecmp(msg_type, "Get Problems")) { |
| return DBD_GET_PROBS; |
| } else if (!xstrcasecmp(msg_type, "Get Resources")) { |
| return DBD_GET_RES; |
| } else if (!xstrcasecmp(msg_type, "Get Users")) { |
| return DBD_GET_USERS; |
| } else if (!xstrcasecmp(msg_type, "Got Accounts")) { |
| return DBD_GOT_ACCOUNTS; |
| } else if (!xstrcasecmp(msg_type, "Got TRES")) { |
| return DBD_GOT_TRES; |
| } else if (!xstrcasecmp(msg_type, "Got Associations")) { |
| return DBD_GOT_ASSOCS; |
| } else if (!xstrcasecmp(msg_type, "Got Association Usage")) { |
| return DBD_GOT_ASSOC_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Got Clusters")) { |
| return DBD_GOT_CLUSTERS; |
| } else if (!xstrcasecmp(msg_type, "Got Cluster Usage")) { |
| return DBD_GOT_CLUSTER_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Got Events")) { |
| return DBD_GOT_EVENTS; |
| } else if (!xstrcasecmp(msg_type, "Got Federations")) { |
| return DBD_GOT_FEDERATIONS; |
| } else if (!xstrcasecmp(msg_type, "Got Instances")) { |
| return DBD_GOT_INSTANCES; |
| } else if (!xstrcasecmp(msg_type, "Got Jobs")) { |
| return DBD_GOT_JOBS; |
| } else if (!xstrcasecmp(msg_type, "Got List")) { |
| return DBD_GOT_LIST; |
| } else if (!xstrcasecmp(msg_type, "Got Problems")) { |
| return DBD_GOT_PROBS; |
| } else if (!xstrcasecmp(msg_type, "Got Resources")) { |
| return DBD_GOT_RES; |
| } else if (!xstrcasecmp(msg_type, "Got Users")) { |
| return DBD_GOT_USERS; |
| } else if (!xstrcasecmp(msg_type, "Job Complete")) { |
| return DBD_JOB_COMPLETE; |
| } else if (!xstrcasecmp(msg_type, "Job Start")) { |
| return DBD_JOB_START; |
| } else if (!xstrcasecmp(msg_type, "Job Heavy")) { |
| return DBD_JOB_HEAVY; |
| } else if (!xstrcasecmp(msg_type, "ID RC")) { |
| return DBD_ID_RC; |
| } else if (!xstrcasecmp(msg_type, "Job Suspend")) { |
| return DBD_JOB_SUSPEND; |
| } else if (!xstrcasecmp(msg_type, "Modify Accounts")) { |
| return DBD_MODIFY_ACCOUNTS; |
| } else if (!xstrcasecmp(msg_type, "Modify Associations")) { |
| return DBD_MODIFY_ASSOCS; |
| } else if (!xstrcasecmp(msg_type, "Modify Clusters")) { |
| return DBD_MODIFY_CLUSTERS; |
| } else if (!xstrcasecmp(msg_type, "Modify Federations")) { |
| return DBD_MODIFY_FEDERATIONS; |
| } else if (!xstrcasecmp(msg_type, "Modify Job")) { |
| return DBD_MODIFY_JOB; |
| } else if (!xstrcasecmp(msg_type, "Modify QOS")) { |
| return DBD_MODIFY_QOS; |
| } else if (!xstrcasecmp(msg_type, "Modify Resources")) { |
| return DBD_MODIFY_RES; |
| } else if (!xstrcasecmp(msg_type, "Modify Users")) { |
| return DBD_MODIFY_USERS; |
| } else if (!xstrcasecmp(msg_type, "Node State")) { |
| return DBD_NODE_STATE; |
| } else if (!xstrcasecmp(msg_type, "Register Cluster")) { |
| return DBD_REGISTER_CTLD; |
| } else if (!xstrcasecmp(msg_type, "Remove Accounts")) { |
| return DBD_REMOVE_ACCOUNTS; |
| } else if (!xstrcasecmp(msg_type, "Remove Account Coords")) { |
| return DBD_REMOVE_ACCOUNT_COORDS; |
| } else if (!xstrcasecmp(msg_type, "Archive Dump")) { |
| return DBD_ARCHIVE_DUMP; |
| } else if (!xstrcasecmp(msg_type, "Archive Load")) { |
| return DBD_ARCHIVE_LOAD; |
| } else if (!xstrcasecmp(msg_type, "Remove Associations")) { |
| return DBD_REMOVE_ASSOCS; |
| } else if (!xstrcasecmp(msg_type, "Remove Clusters")) { |
| return DBD_REMOVE_CLUSTERS; |
| } else if (!xstrcasecmp(msg_type, "Remove Federations")) { |
| return DBD_REMOVE_FEDERATIONS; |
| } else if (!xstrcasecmp(msg_type, "Remove Resources")) { |
| return DBD_REMOVE_RES; |
| } else if (!xstrcasecmp(msg_type, "Remove Users")) { |
| return DBD_REMOVE_USERS; |
| } else if (!xstrcasecmp(msg_type, "Roll Usage")) { |
| return DBD_ROLL_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Step Complete")) { |
| return DBD_STEP_COMPLETE; |
| } else if (!xstrcasecmp(msg_type, "Step Start")) { |
| return DBD_STEP_START; |
| } else if (!xstrcasecmp(msg_type, "Get Jobs Conditional")) { |
| return DBD_GET_JOBS_COND; |
| } else if (!xstrcasecmp(msg_type, "Get Transactions")) { |
| return DBD_GET_TXN; |
| } else if (!xstrcasecmp(msg_type, "Got Transactions")) { |
| return DBD_GOT_TXN; |
| } else if (!xstrcasecmp(msg_type, "Add QOS")) { |
| return DBD_ADD_QOS; |
| } else if (!xstrcasecmp(msg_type, "Get QOS")) { |
| return DBD_GET_QOS; |
| } else if (!xstrcasecmp(msg_type, "Got QOS")) { |
| return DBD_GOT_QOS; |
| } else if (!xstrcasecmp(msg_type, "Get QOS Usage")) { |
| return DBD_GET_QOS_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Got QOS Usage")) { |
| return DBD_GOT_QOS_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Remove QOS")) { |
| return DBD_REMOVE_QOS; |
| } else if (!xstrcasecmp(msg_type, "Add WCKeys")) { |
| return DBD_ADD_WCKEYS; |
| } else if (!xstrcasecmp(msg_type, "Get WCKeys")) { |
| return DBD_GET_WCKEYS; |
| } else if (!xstrcasecmp(msg_type, "Got WCKeys")) { |
| return DBD_GOT_WCKEYS; |
| } else if (!xstrcasecmp(msg_type, "Remove WCKeys")) { |
| return DBD_REMOVE_WCKEYS; |
| } else if (!xstrcasecmp(msg_type, "Get WCKey Usage")) { |
| return DBD_GET_WCKEY_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Got WCKey Usage")) { |
| return DBD_GOT_WCKEY_USAGE; |
| } else if (!xstrcasecmp(msg_type, "Add Reservation")) { |
| return DBD_ADD_RESV; |
| } else if (!xstrcasecmp(msg_type, "Remove Reservation")) { |
| return DBD_REMOVE_RESV; |
| } else if (!xstrcasecmp(msg_type, "Modify Reservation")) { |
| return DBD_MODIFY_RESV; |
| } else if (!xstrcasecmp(msg_type, "Get Reservations")) { |
| return DBD_GET_RESVS; |
| } else if (!xstrcasecmp(msg_type, "Got Reservations")) { |
| return DBD_GOT_RESVS; |
| } else if (!xstrcasecmp(msg_type, "Get Config")) { |
| return DBD_GET_CONFIG; |
| } else if (!xstrcasecmp(msg_type, "Got Config")) { |
| return DBD_GOT_CONFIG; |
| } else if (!xstrcasecmp(msg_type, "Send Multiple Job Starts")) { |
| return DBD_SEND_MULT_JOB_START; |
| } else if (!xstrcasecmp(msg_type, "Got Multiple Job Starts")) { |
| return DBD_GOT_MULT_JOB_START; |
| } else if (!xstrcasecmp(msg_type, "Send Multiple Messages")) { |
| return DBD_SEND_MULT_MSG; |
| } else if (!xstrcasecmp(msg_type, "Got Multiple Message Returns")) { |
| return DBD_GOT_MULT_MSG; |
| } else if (!xstrcasecmp(msg_type, |
| "Persistent Connection Initialization")) { |
| return SLURM_PERSIST_INIT; |
| } else if (!xstrcasecmp(msg_type, |
| "Persistent TLS Connection Initialization")) { |
| return SLURM_PERSIST_INIT_TLS; |
| } else { |
| return NO_VAL; |
| } |
| |
| return NO_VAL; |
| } |
| |
| extern char *slurmdbd_msg_type_2_str(slurmdbd_msg_type_t msg_type, int get_enum) |
| { |
| static char unk_str[64]; |
| |
| switch (msg_type) { |
| case DBD_FINI: |
| if (get_enum) { |
| return "DBD_FINI"; |
| } else |
| return "Fini"; |
| break; |
| case DBD_ADD_ACCOUNTS: |
| if (get_enum) { |
| return "DBD_ADD_ACCOUNTS"; |
| } else |
| return "Add Accounts"; |
| break; |
| case DBD_ADD_ACCOUNTS_COND: |
| if (get_enum) { |
| return "DBD_ADD_ACCOUNTS_COND"; |
| } else |
| return "Add Accounts Cond"; |
| break; |
| case DBD_ADD_ACCOUNT_COORDS: |
| if (get_enum) { |
| return "DBD_ADD_ACCOUNT_COORDS"; |
| } else |
| return "Add Account Coord"; |
| break; |
| case DBD_ADD_TRES: |
| if (get_enum) { |
| return "DBD_ADD_TRES"; |
| } else |
| return "Add TRES"; |
| break; |
| case DBD_ADD_ASSOCS: |
| if (get_enum) { |
| return "DBD_ADD_ASSOCS"; |
| } else |
| return "Add Associations"; |
| break; |
| case DBD_ADD_CLUSTERS: |
| if (get_enum) { |
| return "DBD_ADD_CLUSTERS"; |
| } else |
| return "Add Clusters"; |
| break; |
| case DBD_ADD_FEDERATIONS: |
| if (get_enum) { |
| return "DBD_ADD_FEDERATIONS"; |
| } else |
| return "Add Clusters"; |
| break; |
| case DBD_ADD_RES: |
| if (get_enum) { |
| return "DBD_ADD_RES"; |
| } else |
| return "Add Resources"; |
| break; |
| case DBD_ADD_USERS: |
| if (get_enum) { |
| return "DBD_ADD_USERS"; |
| } else |
| return "Add Users"; |
| break; |
| case DBD_ADD_USERS_COND: |
| if (get_enum) { |
| return "DBD_ADD_USERS_COND"; |
| } else |
| return "Add Users Cond"; |
| break; |
| case DBD_CLUSTER_TRES: |
| if (get_enum) { |
| return "DBD_CLUSTER_TRES"; |
| } else |
| return "Cluster TRES"; |
| break; |
| case DBD_FLUSH_JOBS: |
| if (get_enum) { |
| return "DBD_FLUSH_JOBS"; |
| } else |
| return "Flush Jobs"; |
| break; |
| case DBD_GET_ACCOUNTS: |
| if (get_enum) { |
| return "DBD_GET_ACCOUNTS"; |
| } else |
| return "Get Accounts"; |
| break; |
| case DBD_GET_TRES: |
| if (get_enum) { |
| return "DBD_GET_TRES"; |
| } else |
| return "Get TRES"; |
| break; |
| case DBD_GET_ASSOCS: |
| if (get_enum) { |
| return "DBD_GET_ASSOCS"; |
| } else |
| return "Get Associations"; |
| break; |
| case DBD_GET_ASSOC_USAGE: |
| if (get_enum) { |
| return "DBD_GET_ASSOC_USAGE"; |
| } else |
| return "Get Association Usage"; |
| break; |
| case DBD_GET_CLUSTERS: |
| if (get_enum) { |
| return "DBD_GET_CLUSTERS"; |
| } else |
| return "Get Clusters"; |
| break; |
| case DBD_GET_CLUSTER_USAGE: |
| if (get_enum) { |
| return "DBD_GET_CLUSTER_USAGE"; |
| } else |
| return "Get Cluster Usage"; |
| break; |
| case DBD_GET_EVENTS: |
| if (get_enum) { |
| return "DBD_GET_EVENTS"; |
| } else |
| return "Get Events"; |
| break; |
| case DBD_GET_FEDERATIONS: |
| if (get_enum) { |
| return "DBD_GET_FEDERATIONS"; |
| } else |
| return "Get Federations"; |
| break; |
| case DBD_GET_INSTANCES: |
| if (get_enum) { |
| return "DBD_GET_INSTANCES"; |
| } else |
| return "Get Instances"; |
| break; |
| case DBD_RECONFIG: |
| if (get_enum) { |
| return "DBD_RECONFIG"; |
| } else |
| return "Reconfigure"; |
| break; |
| case DBD_GET_PROBS: |
| if (get_enum) { |
| return "DBD_GET_PROBS"; |
| } else |
| return "Get Problems"; |
| break; |
| case DBD_GET_RES: |
| if (get_enum) { |
| return "DBD_GET_RES"; |
| } else |
| return "Get Resources"; |
| break; |
| case DBD_GET_USERS: |
| if (get_enum) { |
| return "DBD_GET_USERS"; |
| } else |
| return "Get Users"; |
| break; |
| case DBD_GOT_ACCOUNTS: |
| if (get_enum) { |
| return "DBD_GOT_ACCOUNTS"; |
| } else |
| return "Got Accounts"; |
| break; |
| case DBD_GOT_TRES: |
| if (get_enum) { |
| return "DBD_GOT_TRES"; |
| } else |
| return "Got TRES"; |
| break; |
| case DBD_GOT_ASSOCS: |
| if (get_enum) { |
| return "DBD_GOT_ASSOCS"; |
| } else |
| return "Got Associations"; |
| break; |
| case DBD_GOT_ASSOC_USAGE: |
| if (get_enum) { |
| return "DBD_GOT_ASSOC_USAGE"; |
| } else |
| return "Got Association Usage"; |
| break; |
| case DBD_GOT_CLUSTERS: |
| if (get_enum) { |
| return "DBD_GOT_CLUSTERS"; |
| } else |
| return "Got Clusters"; |
| break; |
| case DBD_GOT_CLUSTER_USAGE: |
| if (get_enum) { |
| return "DBD_GOT_CLUSTER_USAGE"; |
| } else |
| return "Got Cluster Usage"; |
| break; |
| case DBD_GOT_EVENTS: |
| if (get_enum) { |
| return "DBD_GOT_EVENTS"; |
| } else |
| return "Got Events"; |
| break; |
| case DBD_GOT_FEDERATIONS: |
| if (get_enum) { |
| return "DBD_GOT_FEDERATIONS"; |
| } else |
| return "Got Federations"; |
| break; |
| case DBD_GOT_INSTANCES: |
| if (get_enum) { |
| return "DBD_GOT_INSTANCES"; |
| } else |
| return "Got Instances"; |
| break; |
| case DBD_GOT_JOBS: |
| if (get_enum) { |
| return "DBD_GOT_JOBS"; |
| } else |
| return "Got Jobs"; |
| break; |
| case DBD_GOT_LIST: |
| if (get_enum) { |
| return "DBD_GOT_LIST"; |
| } else |
| return "Got List"; |
| break; |
| case DBD_GOT_PROBS: |
| if (get_enum) { |
| return "DBD_GOT_PROBS"; |
| } else |
| return "Got Problems"; |
| break; |
| case DBD_GOT_RES: |
| if (get_enum) { |
| return "DBD_GOT_RES"; |
| } else |
| return "Got Resources"; |
| break; |
| case DBD_GOT_USERS: |
| if (get_enum) { |
| return "DBD_GOT_USERS"; |
| } else |
| return "Got Users"; |
| break; |
| case DBD_JOB_COMPLETE: |
| if (get_enum) { |
| return "DBD_JOB_COMPLETE"; |
| } else |
| return "Job Complete"; |
| break; |
| case DBD_JOB_START: |
| if (get_enum) { |
| return "DBD_JOB_START"; |
| } else |
| return "Job Start"; |
| break; |
| case DBD_JOB_HEAVY: |
| if (get_enum) { |
| return "DBD_JOB_HEAVY"; |
| } else |
| return "Job Heavy"; |
| break; |
| case DBD_ID_RC: |
| if (get_enum) { |
| return "DBD_ID_RC"; |
| } else |
| return "ID RC"; |
| break; |
| case DBD_JOB_SUSPEND: |
| if (get_enum) { |
| return "DBD_JOB_SUSPEND"; |
| } else |
| return "Job Suspend"; |
| break; |
| case DBD_MODIFY_ACCOUNTS: |
| if (get_enum) { |
| return "DBD_MODIFY_ACCOUNTS"; |
| } else |
| return "Modify Accounts"; |
| break; |
| case DBD_MODIFY_ASSOCS: |
| if (get_enum) { |
| return "DBD_MODIFY_ASSOCS"; |
| } else |
| return "Modify Associations"; |
| break; |
| case DBD_MODIFY_CLUSTERS: |
| if (get_enum) { |
| return "DBD_MODIFY_CLUSTERS"; |
| } else |
| return "Modify Clusters"; |
| break; |
| case DBD_MODIFY_FEDERATIONS: |
| if (get_enum) { |
| return "DBD_MODIFY_FEDERATIONS"; |
| } else |
| return "Modify Federations"; |
| break; |
| case DBD_MODIFY_JOB: |
| if (get_enum) { |
| return "DBD_MODIFY_JOB"; |
| } else |
| return "Modify Job"; |
| break; |
| case DBD_MODIFY_QOS: |
| if (get_enum) { |
| return "DBD_MODIFY_QOS"; |
| } else |
| return "Modify QOS"; |
| break; |
| case DBD_MODIFY_RES: |
| if (get_enum) { |
| return "DBD_MODIFY_RES"; |
| } else |
| return "Modify Resources"; |
| break; |
| case DBD_MODIFY_USERS: |
| if (get_enum) { |
| return "DBD_MODIFY_USERS"; |
| } else |
| return "Modify Users"; |
| break; |
| case DBD_NODE_STATE: |
| if (get_enum) { |
| return "DBD_NODE_STATE"; |
| } else |
| return "Node State"; |
| break; |
| case DBD_REGISTER_CTLD: |
| if (get_enum) { |
| return "DBD_REGISTER_CTLD"; |
| } else |
| return "Register Cluster"; |
| break; |
| case DBD_REMOVE_ACCOUNTS: |
| if (get_enum) { |
| return "DBD_REMOVE_ACCOUNTS"; |
| } else |
| return "Remove Accounts"; |
| break; |
| case DBD_REMOVE_ACCOUNT_COORDS: |
| if (get_enum) { |
| return "DBD_REMOVE_ACCOUNT_COORDS"; |
| } else |
| return "Remove Account Coords"; |
| break; |
| case DBD_ARCHIVE_DUMP: |
| if (get_enum) { |
| return "DBD_ARCHIVE_DUMP"; |
| } else |
| return "Archive Dump"; |
| break; |
| case DBD_ARCHIVE_LOAD: |
| if (get_enum) { |
| return "DBD_ARCHIVE_LOAD"; |
| } else |
| return "Archive Load"; |
| break; |
| case DBD_REMOVE_ASSOCS: |
| if (get_enum) { |
| return "DBD_REMOVE_ASSOCS"; |
| } else |
| return "Remove Associations"; |
| break; |
| case DBD_REMOVE_CLUSTERS: |
| if (get_enum) { |
| return "DBD_REMOVE_CLUSTERS"; |
| } else |
| return "Remove Clusters"; |
| break; |
| case DBD_REMOVE_FEDERATIONS: |
| if (get_enum) { |
| return "DBD_REMOVE_FEDERATIONS"; |
| } else |
| return "Remove Federations"; |
| break; |
| case DBD_REMOVE_RES: |
| if (get_enum) { |
| return "DBD_REMOVE_RES"; |
| } else |
| return "Remove Resources"; |
| break; |
| case DBD_REMOVE_USERS: |
| if (get_enum) { |
| return "DBD_REMOVE_USERS"; |
| } else |
| return "Remove Users"; |
| break; |
| case DBD_ROLL_USAGE: |
| if (get_enum) { |
| return "DBD_ROLL_USAGE"; |
| } else |
| return "Roll Usage"; |
| break; |
| case DBD_STEP_COMPLETE: |
| if (get_enum) { |
| return "DBD_STEP_COMPLETE"; |
| } else |
| return "Step Complete"; |
| break; |
| case DBD_STEP_START: |
| if (get_enum) { |
| return "DBD_STEP_START"; |
| } else |
| return "Step Start"; |
| break; |
| case DBD_GET_JOBS_COND: |
| if (get_enum) { |
| return "DBD_GET_JOBS_COND"; |
| } else |
| return "Get Jobs Conditional"; |
| break; |
| case DBD_GET_TXN: |
| if (get_enum) { |
| return "DBD_GET_TXN"; |
| } else |
| return "Get Transactions"; |
| break; |
| case DBD_GOT_TXN: |
| if (get_enum) { |
| return "DBD_GOT_TXN"; |
| } else |
| return "Got Transactions"; |
| break; |
| case DBD_ADD_QOS: |
| if (get_enum) { |
| return "DBD_ADD_QOS"; |
| } else |
| return "Add QOS"; |
| break; |
| case DBD_GET_QOS: |
| if (get_enum) { |
| return "DBD_GET_QOS"; |
| } else |
| return "Get QOS"; |
| break; |
| case DBD_GOT_QOS: |
| if (get_enum) { |
| return "DBD_GOT_QOS"; |
| } else |
| return "Got QOS"; |
| break; |
| case DBD_GET_QOS_USAGE: |
| if (get_enum) { |
| return "DBD_GET_QOS_USAGE"; |
| } else |
| return "Get QOS Usage"; |
| break; |
| case DBD_GOT_QOS_USAGE: |
| if (get_enum) { |
| return "DBD_GOT_QOS_USAGE"; |
| } else |
| return "Got QOS Usage"; |
| break; |
| case DBD_REMOVE_QOS: |
| if (get_enum) { |
| return "DBD_REMOVE_QOS"; |
| } else |
| return "Remove QOS"; |
| break; |
| case DBD_ADD_WCKEYS: |
| if (get_enum) { |
| return "DBD_ADD_WCKEYS"; |
| } else |
| return "Add WCKeys"; |
| break; |
| case DBD_GET_WCKEYS: |
| if (get_enum) { |
| return "DBD_GET_WCKEYS"; |
| } else |
| return "Get WCKeys"; |
| break; |
| case DBD_GOT_WCKEYS: |
| if (get_enum) { |
| return "DBD_GOT_WCKEYS"; |
| } else |
| return "Got WCKeys"; |
| break; |
| case DBD_REMOVE_WCKEYS: |
| if (get_enum) { |
| return "DBD_REMOVE_WCKEYS"; |
| } else |
| return "Remove WCKeys"; |
| break; |
| case DBD_GET_WCKEY_USAGE: |
| if (get_enum) { |
| return "DBD_GET_WCKEY_USAGE"; |
| } else |
| return "Get WCKey Usage"; |
| break; |
| case DBD_GOT_WCKEY_USAGE: |
| if (get_enum) { |
| return "DBD_GOT_WCKEY_USAGE"; |
| } else |
| return "Got WCKey Usage"; |
| break; |
| case DBD_ADD_RESV: |
| if (get_enum) { |
| return "DBD_ADD_RESV"; |
| } else |
| return "Add Reservation"; |
| break; |
| case DBD_REMOVE_RESV: |
| if (get_enum) { |
| return "DBD_REMOVE_RESV"; |
| } else |
| return "Remove Reservation"; |
| break; |
| case DBD_MODIFY_RESV: |
| if (get_enum) { |
| return "DBD_MODIFY_RESV"; |
| } else |
| return "Modify Reservation"; |
| break; |
| case DBD_GET_RESVS: |
| if (get_enum) { |
| return "DBD_GET_RESVS"; |
| } else |
| return "Get Reservations"; |
| break; |
| case DBD_GOT_RESVS: |
| if (get_enum) { |
| return "DBD_GOT_RESVS"; |
| } else |
| return "Got Reservations"; |
| break; |
| case DBD_GET_CONFIG: |
| if (get_enum) { |
| return "DBD_GET_CONFIG"; |
| } else |
| return "Get Config"; |
| break; |
| case DBD_GOT_CONFIG: |
| if (get_enum) { |
| return "DBD_GOT_CONFIG"; |
| } else |
| return "Got Config"; |
| break; |
| case DBD_SEND_MULT_JOB_START: |
| if (get_enum) { |
| return "DBD_SEND_MULT_JOB_START"; |
| } else |
| return "Send Multiple Job Starts"; |
| break; |
| case DBD_GOT_MULT_JOB_START: |
| if (get_enum) { |
| return "DBD_GOT_MULT_JOB_START"; |
| } else |
| return "Got Multiple Job Starts"; |
| break; |
| case DBD_SEND_MULT_MSG: |
| if (get_enum) { |
| return "DBD_SEND_MULT_MSG"; |
| } else |
| return "Send Multiple Messages"; |
| break; |
| case DBD_GOT_MULT_MSG: |
| if (get_enum) { |
| return "DBD_GOT_MULT_MSG"; |
| } else |
| return "Got Multiple Message Returns"; |
| break; |
| case DBD_GET_STATS: |
| if (get_enum) { |
| return "DBD_GET_STATS"; |
| } else |
| return "Get daemon statistics"; |
| break; |
| case DBD_GOT_STATS: |
| if (get_enum) { |
| return "DBD_GOT_STATS"; |
| } else |
| return "Got daemon statistics data"; |
| break; |
| case DBD_CLEAR_STATS: |
| if (get_enum) { |
| return "DBD_CLEAR_STATS"; |
| } else |
| return "Clear daemon statistics"; |
| break; |
| case DBD_SHUTDOWN: |
| if (get_enum) { |
| return "DBD_SHUTDOWN"; |
| } else |
| return "Shutdown daemon"; |
| break; |
| case SLURM_PERSIST_INIT: |
| if (get_enum) { |
| return "SLURM_PERSIST_INIT"; |
| } else |
| return "Persistent Connection Initialization"; |
| break; |
| case SLURM_PERSIST_INIT_TLS: |
| if (get_enum) { |
| return "SLURM_PERSIST_INIT_TLS"; |
| } else |
| return "Persistent TLS Connection Initialization"; |
| break; |
| default: |
| snprintf(unk_str, sizeof(unk_str), "MsgType=%d", msg_type); |
| return unk_str; |
| break; |
| } |
| } |
| |
| |
| /****************************************************************************\ |
| * Free data structures |
| \****************************************************************************/ |
| extern void slurmdbd_free_buffer(void *x) |
| { |
| buf_t *buffer = (buf_t *) x; |
| FREE_NULL_BUFFER(buffer); |
| } |
| |
| extern void slurmdbd_free_acct_coord_msg(dbd_acct_coord_msg_t *msg) |
| { |
| if (msg) { |
| FREE_NULL_LIST(msg->acct_list); |
| slurmdb_destroy_user_cond(msg->cond); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_cluster_tres_msg(dbd_cluster_tres_msg_t *msg) |
| { |
| if (msg) { |
| xfree(msg->cluster_nodes); |
| xfree(msg->tres_str); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_msg(persist_msg_t *msg) |
| { |
| switch (msg->msg_type) { |
| case DBD_ADD_ACCOUNTS: |
| case DBD_ADD_TRES: |
| case DBD_ADD_ASSOCS: |
| case DBD_ADD_CLUSTERS: |
| case DBD_ADD_FEDERATIONS: |
| case DBD_ADD_RES: |
| case DBD_ADD_USERS: |
| case DBD_GOT_ACCOUNTS: |
| case DBD_GOT_TRES: |
| case DBD_GOT_ASSOCS: |
| case DBD_GOT_CLUSTERS: |
| case DBD_GOT_EVENTS: |
| case DBD_GOT_FEDERATIONS: |
| case DBD_GOT_INSTANCES: |
| case DBD_GOT_JOBS: |
| case DBD_GOT_LIST: |
| case DBD_GOT_PROBS: |
| case DBD_GOT_RES: |
| case DBD_ADD_QOS: |
| case DBD_GOT_QOS: |
| case DBD_GOT_RESVS: |
| case DBD_ADD_WCKEYS: |
| case DBD_GOT_WCKEYS: |
| case DBD_GOT_TXN: |
| case DBD_GOT_USERS: |
| case DBD_GOT_CONFIG: |
| case DBD_SEND_MULT_JOB_START: |
| case DBD_GOT_MULT_JOB_START: |
| case DBD_SEND_MULT_MSG: |
| case DBD_GOT_MULT_MSG: |
| case DBD_FIX_RUNAWAY_JOB: |
| slurmdbd_free_list_msg(msg->data); |
| break; |
| case DBD_ADD_ACCOUNT_COORDS: |
| case DBD_REMOVE_ACCOUNT_COORDS: |
| slurmdbd_free_acct_coord_msg(msg->data); |
| break; |
| case DBD_ARCHIVE_LOAD: |
| slurmdb_destroy_archive_rec(msg->data); |
| break; |
| case DBD_CLUSTER_TRES: |
| case DBD_FLUSH_JOBS: |
| slurmdbd_free_cluster_tres_msg(msg->data); |
| break; |
| case DBD_GET_ACCOUNTS: |
| case DBD_GET_TRES: |
| case DBD_GET_ASSOCS: |
| case DBD_GET_CLUSTERS: |
| case DBD_GET_EVENTS: |
| case DBD_GET_FEDERATIONS: |
| case DBD_GET_INSTANCES: |
| case DBD_GET_JOBS_COND: |
| case DBD_GET_PROBS: |
| case DBD_GET_QOS: |
| case DBD_GET_RESVS: |
| case DBD_GET_RES: |
| case DBD_GET_TXN: |
| case DBD_GET_USERS: |
| case DBD_GET_WCKEYS: |
| case DBD_REMOVE_ACCOUNTS: |
| case DBD_REMOVE_ASSOCS: |
| case DBD_REMOVE_CLUSTERS: |
| case DBD_REMOVE_FEDERATIONS: |
| case DBD_REMOVE_QOS: |
| case DBD_REMOVE_RES: |
| case DBD_REMOVE_WCKEYS: |
| case DBD_REMOVE_USERS: |
| case DBD_ARCHIVE_DUMP: |
| slurmdbd_free_cond_msg(msg->data, msg->msg_type); |
| break; |
| case DBD_GET_ASSOC_USAGE: |
| case DBD_GOT_ASSOC_USAGE: |
| case DBD_GET_CLUSTER_USAGE: |
| case DBD_GOT_CLUSTER_USAGE: |
| case DBD_GET_WCKEY_USAGE: |
| case DBD_GOT_WCKEY_USAGE: |
| slurmdbd_free_usage_msg(msg->data, msg->msg_type); |
| break; |
| case DBD_FINI: |
| slurmdbd_free_fini_msg(msg->data); |
| break; |
| case DBD_JOB_COMPLETE: |
| slurmdbd_free_job_complete_msg(msg->data); |
| break; |
| case DBD_JOB_START: |
| slurmdbd_free_job_start_msg(msg->data); |
| break; |
| case DBD_JOB_HEAVY: |
| slurmdbd_free_job_heavy_msg(msg->data); |
| break; |
| case DBD_JOB_SUSPEND: |
| slurmdbd_free_job_suspend_msg(msg->data); |
| break; |
| case DBD_ADD_ACCOUNTS_COND: |
| case DBD_ADD_USERS_COND: |
| case DBD_MODIFY_ACCOUNTS: |
| case DBD_MODIFY_ASSOCS: |
| case DBD_MODIFY_CLUSTERS: |
| case DBD_MODIFY_FEDERATIONS: |
| case DBD_MODIFY_JOB: |
| case DBD_MODIFY_QOS: |
| case DBD_MODIFY_RES: |
| case DBD_MODIFY_USERS: |
| slurmdbd_free_modify_msg(msg->data, msg->msg_type); |
| break; |
| case DBD_NODE_STATE: |
| slurmdbd_free_node_state_msg(msg->data); |
| break; |
| case DBD_STEP_COMPLETE: |
| slurmdbd_free_step_complete_msg(msg->data); |
| break; |
| case DBD_STEP_START: |
| slurmdbd_free_step_start_msg(msg->data); |
| break; |
| case DBD_REGISTER_CTLD: |
| slurmdbd_free_register_ctld_msg(msg->data); |
| break; |
| case DBD_ROLL_USAGE: |
| slurmdbd_free_roll_usage_msg(msg->data); |
| break; |
| case DBD_ADD_RESV: |
| case DBD_REMOVE_RESV: |
| case DBD_MODIFY_RESV: |
| slurmdbd_free_rec_msg(msg->data, msg->msg_type); |
| break; |
| case DBD_GET_CONFIG: |
| case DBD_RECONFIG: |
| case DBD_GET_STATS: |
| case DBD_CLEAR_STATS: |
| case DBD_SHUTDOWN: |
| break; |
| case SLURM_PERSIST_INIT: |
| case SLURM_PERSIST_INIT_TLS: |
| slurm_free_msg(msg->data); |
| break; |
| default: |
| error("%s: Unknown rec type %d(%s)", |
| __func__, msg->msg_type, |
| slurmdbd_msg_type_2_str(msg->msg_type, true)); |
| return; |
| } |
| } |
| |
| extern void slurmdbd_free_rec_msg(dbd_rec_msg_t *msg, |
| slurmdbd_msg_type_t type) |
| { |
| void (*my_destroy) (void *object); |
| |
| if (msg) { |
| switch (type) { |
| case DBD_ADD_RESV: |
| case DBD_REMOVE_RESV: |
| case DBD_MODIFY_RESV: |
| my_destroy = slurmdb_destroy_reservation_rec; |
| break; |
| default: |
| fatal("Unknown rec type"); |
| return; |
| } |
| if (msg->rec) |
| (*(my_destroy))(msg->rec); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_cond_msg(dbd_cond_msg_t *msg, |
| slurmdbd_msg_type_t type) |
| { |
| void (*my_destroy) (void *object); |
| |
| if (msg) { |
| switch (type) { |
| case DBD_GET_ACCOUNTS: |
| case DBD_REMOVE_ACCOUNTS: |
| my_destroy = slurmdb_destroy_account_cond; |
| break; |
| case DBD_GET_TRES: |
| my_destroy = slurmdb_destroy_tres_cond; |
| break; |
| case DBD_GET_ASSOCS: |
| case DBD_GET_PROBS: |
| case DBD_REMOVE_ASSOCS: |
| my_destroy = slurmdb_destroy_assoc_cond; |
| break; |
| case DBD_GET_CLUSTERS: |
| case DBD_REMOVE_CLUSTERS: |
| my_destroy = slurmdb_destroy_cluster_cond; |
| break; |
| case DBD_GET_FEDERATIONS: |
| case DBD_REMOVE_FEDERATIONS: |
| my_destroy = slurmdb_destroy_federation_cond; |
| break; |
| case DBD_GET_JOBS_COND: |
| my_destroy = slurmdb_destroy_job_cond; |
| break; |
| case DBD_GET_QOS: |
| case DBD_REMOVE_QOS: |
| my_destroy = slurmdb_destroy_qos_cond; |
| break; |
| case DBD_GET_RES: |
| case DBD_REMOVE_RES: |
| my_destroy = slurmdb_destroy_res_cond; |
| break; |
| case DBD_GET_WCKEYS: |
| case DBD_REMOVE_WCKEYS: |
| my_destroy = slurmdb_destroy_wckey_cond; |
| break; |
| case DBD_GET_TXN: |
| my_destroy = slurmdb_destroy_txn_cond; |
| break; |
| case DBD_GET_USERS: |
| case DBD_REMOVE_USERS: |
| my_destroy = slurmdb_destroy_user_cond; |
| break; |
| case DBD_ARCHIVE_DUMP: |
| my_destroy = slurmdb_destroy_archive_cond; |
| break; |
| case DBD_GET_RESVS: |
| my_destroy = slurmdb_destroy_reservation_cond; |
| break; |
| case DBD_GET_EVENTS: |
| my_destroy = slurmdb_destroy_event_cond; |
| break; |
| case DBD_GET_INSTANCES: |
| my_destroy = slurmdb_destroy_instance_cond; |
| break; |
| default: |
| fatal("Unknown cond type"); |
| return; |
| } |
| if (msg->cond) |
| (*(my_destroy))(msg->cond); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_fini_msg(dbd_fini_msg_t *msg) |
| { |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_job_complete_msg(dbd_job_comp_msg_t *msg) |
| { |
| if (msg) { |
| xfree(msg->admin_comment); |
| xfree(msg->comment); |
| xfree(msg->extra); |
| xfree(msg->failed_node); |
| xfree(msg->nodes); |
| xfree(msg->system_comment); |
| xfree(msg->tres_alloc_str); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_job_start_msg(void *in) |
| { |
| dbd_job_start_msg_t *msg = (dbd_job_start_msg_t *)in; |
| if (msg) { |
| xfree(msg->account); |
| xfree(msg->array_task_str); |
| xfree(msg->constraints); |
| xfree(msg->container); |
| xfree(msg->env_hash); |
| xfree(msg->gres_used); |
| xfree(msg->licenses); |
| xfree(msg->mcs_label); |
| xfree(msg->name); |
| xfree(msg->nodes); |
| xfree(msg->node_inx); |
| xfree(msg->partition); |
| xfree(msg->qos_req); |
| xfree(msg->resv_req); |
| xfree(msg->script_hash); |
| xfree(msg->std_err); |
| xfree(msg->std_in); |
| xfree(msg->std_out); |
| xfree(msg->submit_line); |
| xfree(msg->tres_alloc_str); |
| xfree(msg->tres_req_str); |
| xfree(msg->wckey); |
| xfree(msg->work_dir); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_job_heavy_msg(void *in) |
| { |
| dbd_job_heavy_msg_t *msg = in; |
| |
| if (!msg) |
| return; |
| |
| xfree(msg->env); |
| xfree(msg->env_hash); |
| xfree(msg->script); |
| FREE_NULL_BUFFER(msg->script_buf); |
| xfree(msg->script_hash); |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_id_rc_msg(void *in) |
| { |
| dbd_id_rc_msg_t *msg = (dbd_id_rc_msg_t *)in; |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_job_suspend_msg(dbd_job_suspend_msg_t *msg) |
| { |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_list_msg(dbd_list_msg_t *msg) |
| { |
| if (msg) { |
| FREE_NULL_LIST(msg->my_list); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_modify_msg(dbd_modify_msg_t *msg, |
| slurmdbd_msg_type_t type) |
| { |
| void (*destroy_cond) (void *object); |
| void (*destroy_rec) (void *object); |
| |
| if (msg) { |
| switch (type) { |
| case DBD_ADD_ACCOUNTS_COND: |
| destroy_cond = slurmdb_destroy_add_assoc_cond; |
| destroy_rec = slurmdb_destroy_account_rec; |
| break; |
| case DBD_ADD_USERS_COND: |
| destroy_cond = slurmdb_destroy_add_assoc_cond; |
| destroy_rec = slurmdb_destroy_user_rec; |
| break; |
| case DBD_MODIFY_ACCOUNTS: |
| destroy_cond = slurmdb_destroy_account_cond; |
| destroy_rec = slurmdb_destroy_account_rec; |
| break; |
| case DBD_MODIFY_ASSOCS: |
| destroy_cond = slurmdb_destroy_assoc_cond; |
| destroy_rec = slurmdb_destroy_assoc_rec; |
| break; |
| case DBD_MODIFY_CLUSTERS: |
| destroy_cond = slurmdb_destroy_cluster_cond; |
| destroy_rec = slurmdb_destroy_cluster_rec; |
| break; |
| case DBD_MODIFY_FEDERATIONS: |
| destroy_cond = slurmdb_destroy_federation_cond; |
| destroy_rec = slurmdb_destroy_federation_rec; |
| break; |
| case DBD_MODIFY_JOB: |
| destroy_cond = slurmdb_destroy_job_cond; |
| destroy_rec = slurmdb_destroy_job_rec; |
| break; |
| case DBD_MODIFY_QOS: |
| destroy_cond = slurmdb_destroy_qos_cond; |
| destroy_rec = slurmdb_destroy_qos_rec; |
| break; |
| case DBD_MODIFY_RES: |
| destroy_cond = slurmdb_destroy_res_cond; |
| destroy_rec = slurmdb_destroy_res_rec; |
| break; |
| case DBD_MODIFY_USERS: |
| destroy_cond = slurmdb_destroy_user_cond; |
| destroy_rec = slurmdb_destroy_user_rec; |
| break; |
| default: |
| fatal("Unknown modify type"); |
| return; |
| } |
| |
| if (msg->cond) |
| (*(destroy_cond))(msg->cond); |
| if (msg->rec) |
| (*(destroy_rec))(msg->rec); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_node_state_msg(dbd_node_state_msg_t *msg) |
| { |
| if (msg) { |
| xfree(msg->hostlist); |
| xfree(msg->extra); |
| xfree(msg->instance_id); |
| xfree(msg->instance_type); |
| xfree(msg->reason); |
| xfree(msg->tres_str); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_register_ctld_msg(dbd_register_ctld_msg_t *msg) |
| { |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_roll_usage_msg(dbd_roll_usage_msg_t *msg) |
| { |
| xfree(msg); |
| } |
| |
| extern void slurmdbd_free_step_complete_msg(dbd_step_comp_msg_t *msg) |
| { |
| if (msg) { |
| jobacctinfo_destroy(msg->jobacct); |
| xfree(msg->job_tres_alloc_str); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_step_start_msg(dbd_step_start_msg_t *msg) |
| { |
| if (msg) { |
| xfree(msg->container); |
| xfree(msg->name); |
| xfree(msg->nodes); |
| xfree(msg->node_inx); |
| xfree(msg->cwd); |
| xfree(msg->std_err); |
| xfree(msg->std_in); |
| xfree(msg->std_out); |
| xfree(msg->submit_line); |
| xfree(msg->tres_alloc_str); |
| xfree(msg); |
| } |
| } |
| |
| extern void slurmdbd_free_usage_msg(dbd_usage_msg_t *msg, |
| slurmdbd_msg_type_t type) |
| { |
| void (*destroy_rec) (void *object); |
| if (msg) { |
| switch (type) { |
| case DBD_GET_ASSOC_USAGE: |
| case DBD_GOT_ASSOC_USAGE: |
| destroy_rec = slurmdb_destroy_assoc_rec; |
| break; |
| case DBD_GET_CLUSTER_USAGE: |
| case DBD_GOT_CLUSTER_USAGE: |
| destroy_rec = slurmdb_destroy_cluster_rec; |
| break; |
| case DBD_GET_WCKEY_USAGE: |
| case DBD_GOT_WCKEY_USAGE: |
| destroy_rec = slurmdb_destroy_wckey_rec; |
| break; |
| default: |
| fatal("Unknown usage type"); |
| return; |
| } |
| |
| if (msg->rec) |
| (*(destroy_rec))(msg->rec); |
| xfree(msg); |
| } |
| } |
