Logo Search packages:      
Sourcecode: slurm-llnl version File versions  Download package

slurm_protocol_api.h

/*****************************************************************************\
 *  slurm_protocol_api.h - high-level slurm communication functions 
 *    definitions
 *****************************************************************************
 *  Copyright (C) 2002-2006 The Regents of the University of California.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Kevin Tew <tew1@llnl.gov>, et. al.
 *  UCRL-CODE-226842.
 *  
 *  This file is part of SLURM, a resource management program.
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 *  
 *  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.
\*****************************************************************************/

#ifndef _SLURM_PROTOCOL_API_H
#define _SLURM_PROTOCOL_API_H

#if HAVE_CONFIG_H
#  include "config.h"
#  if HAVE_INTTYPES_H
#    include <inttypes.h>
#  else
#    if HAVE_STDINT_H
#      include <stdint.h>
#    endif
#  endif                /* HAVE_INTTYPES_H */
#else                   /* !HAVE_CONFIG_H */
#  include <inttypes.h>
#endif                        /*  HAVE_CONFIG_H */

#include <sys/types.h>
#include <stdarg.h>

#include <slurm/slurm_errno.h>

#include "src/common/pack.h"
#include "src/common/slurm_protocol_common.h"
#include "src/common/slurm_protocol_defs.h"
#include "src/common/slurm_protocol_util.h"

#define MIN_NOALLOC_JOBID ((uint32_t) 0xffff0000)
#define MAX_NOALLOC_JOBID ((uint32_t) 0xfffffffd)

enum controller_id {
      PRIMARY_CONTROLLER = 1,
      SECONDARY_CONTROLLER = 2
};

/* unit types */
enum {
      UNIT_NONE,
      UNIT_KILO,
      UNIT_MEGA,
      UNIT_GIGA,
      UNIT_PETA,
      UNIT_UNKNOWN
};

/**********************************************************************\
 * protocol configuration functions                
\**********************************************************************/

/* slurm_set_api_config
 * sets the slurm_protocol_config object
 * IN protocol_conf           -  slurm_protocol_config object
 */
int inline slurm_set_api_config(slurm_protocol_config_t * protocol_conf);

/* slurm_get_api_config
 * returns a pointer to the current slurm_protocol_config object
 * RET slurm_protocol_config_t      - current slurm_protocol_config object
 */
inline slurm_protocol_config_t *slurm_get_api_config();

/* slurm_get_mpi_default
 * get default mpi value from slurmctld_conf object
 * RET char *   - mpi default value from slurm.conf,  MUST be xfreed by caller
 */
char *slurm_get_mpi_default(void);

/* slurm_get_msg_timeout
 * get default message timeout value from slurmctld_conf object
 */
uint16_t inline slurm_get_msg_timeout(void);

/* slurm_api_set_conf_file
 *      set slurm configuration file to a non-default value
 * pathname IN - pathname of slurm configuration file to be used
 */
extern void slurm_api_set_conf_file(char *pathname);

/* slurm_api_set_default_config
 *    called by the send_controller_msg function to insure that at least 
 *    the compiled in default slurm_protocol_config object is initialized
 * RET int        - return code
 */
int inline slurm_api_set_default_config();

/* slurm_api_clear_config
 * execute this only at program termination to free all memory */
void inline slurm_api_clear_config(void);

/* slurm_get_plugin_dir
 * get plugin directory from slurmctld_conf object from slurmctld_conf object 
 * RET char *   - plugin directory, MUST be xfreed by caller
 */
char *slurm_get_plugin_dir(void);

/* slurm_get_state_save_location
 * get state_save_location from slurmctld_conf object from slurmctld_conf object 
 * RET char *   - state_save_location directory, MUST be xfreed by caller
 */
char *slurm_get_state_save_location(void);

/* slurm_get_auth_type
 * returns the authentication type from slurmctld_conf object
 * RET char *    - auth type, MUST be xfreed by caller
 */
extern char *slurm_get_auth_type(void);

/* slurm_set_auth_type
 * set the authentication type in slurmctld_conf object
 * used for security testing purposes
 * RET 0 or error code
 */
extern int slurm_set_auth_type(char *auth_type);

/* slurm_get_fast_schedule
 * returns the value of fast_schedule in slurmctld_conf object
 */
extern uint16_t slurm_get_fast_schedule(void);

/* slurm_set_tree_width
 * sets the value of tree_width in slurmctld_conf object
 * RET 0 or error code
 */
extern int slurm_set_tree_width(uint16_t tree_width);
/* slurm_get_tree_width
 * returns the value of tree_width in slurmctld_conf object
 */
extern uint16_t slurm_get_tree_width(void);

/* slurm_get_jobacct_loc
 * returns the job accounting loc from slurmctld_conf object
 * RET char *    - job accounting location,  MUST be xfreed by caller
 */
char *slurm_get_jobacct_loc(void);

/* slurm_get_jobacct_freq
 * returns the job accounting poll frequency from the slurmctld_conf object
 * RET int    - job accounting frequency
 */
uint16_t slurm_get_jobacct_freq(void);

/* slurm_get_jobacct_type
 * returns the job accounting type from slurmctld_conf object
 * RET char *    - job accounting type,  MUST be xfreed by caller
 */
char *slurm_get_jobacct_type(void);

/* slurm_get_jobcomp_type
 * returns the job completion logger type from slurmctld_conf object
 * RET char *    - job completion type,  MUST be xfreed by caller
 */
char *slurm_get_jobcomp_type(void);

/* slurm_get_propagate_prio_process
 * return the PropagatePrioProcess flag from slurmctld_conf object
 */
extern uint16_t slurm_get_propagate_prio_process(void);

/* slurm_get_proctrack_type
 * get ProctrackType from slurmctld_conf object
 * RET char *   - proctrack type, MUST be xfreed by caller
 */
char *slurm_get_proctrack_type(void);

/* slurm_get_root_filter
 * RET uint16_t  - Value of SchedulerRootFilter */
extern uint16_t slurm_get_root_filter(void);

/* slurm_get_sched_port
 * RET uint16_t  - Value of SchedulerPort */
extern uint16_t slurm_get_sched_port(void);

/* slurm_get_slurmd_port
 * returns slurmd port from slurmctld_conf object
 * RET uint16_t   - slurmd port
 */
uint16_t inline slurm_get_slurmd_port(void);

/* slurm_get_slurm_user_id
 * returns slurmd uid from slurmctld_conf object 
 * RET uint32_t   - slurm user id
 */
uint32_t slurm_get_slurm_user_id(void);

/* slurm_get_sched_type
 * get sched type from slurmctld_conf object
 * RET char *   - sched type, MUST be xfreed by caller
 */
char *slurm_get_sched_type(void);

/* slurm_get_select_type
 * get select_type from slurmctld_conf object
 * RET char *   - select_type, MUST be xfreed by caller
 */
char *slurm_get_select_type(void);

/* slurm_get_switch_type
 * get switch type from slurmctld_conf object
 * RET char *   - switch type, MUST be xfreed by caller
 */
char *slurm_get_switch_type(void);

/* slurm_get_wait_time
 * returns wait_time from slurmctld_conf object
 * RET uint16_t        - wait_time
 */
uint16_t slurm_get_wait_time(void);

/* slurm_get_srun_prolog
 * return the name of the srun prolog program
 * RET char *   - name of prolog program, must be xfreed by caller
 */
char *slurm_get_srun_prolog(void);

/* slurm_get_srun_epilog
 * return the name of the srun epilog program
 * RET char *   - name of epilog program, must be xfreed by caller
 */
char *slurm_get_srun_epilog(void);

/* slurm_get_task_epilog
 * RET task_epilog name, must be xfreed by caller */
char *slurm_get_task_epilog(void);

/* slurm_get_task_prolog
 * RET task_prolog name, must be xfreed by caller */
char *slurm_get_task_prolog(void);

/* slurm_get_task_plugin
 * RET task_plugin name, must be xfreed by caller */
char *slurm_get_task_plugin(void);

/* slurm_get_task_plugin_param */
uint16_t slurm_get_task_plugin_param(void);

/**********************************************************************\
 * general message management functions used by slurmctld, slurmd
\**********************************************************************/

/* In the socket implementation it creates a socket, binds to it, and 
 *    listens for connections.
 * IN port        - port to bind the msg server to
 * RET slurm_fd         - file descriptor of the connection created
 */
slurm_fd inline slurm_init_msg_engine_port(uint16_t port);

/* In the socket implementation it creates a socket, binds to it, and 
 *    listens for connections.
 * IN slurm_address     - slurm_addr to bind the msg server to 
 * RET slurm_fd         - file descriptor of the connection created
 */
slurm_fd inline slurm_init_msg_engine(slurm_addr * slurm_address);

/* In the bsd implmentation maps directly to a accept call 
 * IN open_fd           - file descriptor to accept connection on
 * OUT slurm_address    - slurm_addr of the accepted connection
 * RET slurm_fd         - file descriptor of the connection created
 */
slurm_fd inline slurm_accept_msg_conn(slurm_fd open_fd,
                              slurm_addr * slurm_address);

/* In the bsd implmentation maps directly to a close call, to close 
 *    the socket that was accepted
 * IN open_fd           - an open file descriptor to close
 * RET int        - the return code
 */
int inline slurm_close_accepted_conn(slurm_fd open_fd);

/* just calls close on an established msg connection
 * IN open_fd     - an open file descriptor to close
 * RET int  - the return code
 */
int inline slurm_shutdown_msg_engine(slurm_fd open_fd);

/**********************************************************************\
 * receive message functions
\**********************************************************************/

/*
 *  Receive a slurm message on the open slurm descriptor "fd" waiting
 *    at most "timeout" seconds for the message data. If timeout is
 *    zero, a default timeout is used. Memory for the message data
 *    (msg->data) is allocated from within this function, and must be
 *    freed at some point using one of the slurm_free* functions.
 *    Also a slurm_cred is allocated (msg->auth_cred) which must be
 *    freed with g_slurm_auth_destroy() if it exists.
 *
 * IN open_fd     - file descriptor to receive msg on
 * OUT msg  - a slurm_msg struct to be filled in by the function
 * IN timeout     - how long to wait in milliseconds
 * RET int  - returns 0 on success, -1 on failure and sets errno
 */
int slurm_receive_msg(slurm_fd fd, slurm_msg_t *msg, int timeout);

/*
 *  Receive a slurm message on the open slurm descriptor "fd" waiting
 *    at most "timeout" seconds for the message data. If timeout is
 *    zero, a default timeout is used. Memory is allocated for the 
 *    returned list and must be freed at some point using the 
 *    list_destroy function.
 *
 * IN open_fd     - file descriptor to receive msg on
 * IN steps - how many steps down the tree we have to wait for
 * IN timeout     - how long to wait in milliseconds
 * RET List - List containing the responses of the childern (if any) we 
 *                forwarded the message to. List containing type
 *                (ret_data_info_t). NULL is returned on failure. and
 *                errno set.
 */
List slurm_receive_msgs(slurm_fd fd, int steps, int timeout);

/*
 *  Receive a slurm message on the open slurm descriptor "fd" waiting
 *    at most "timeout" seconds for the message data. This will also
 *    forward the message to the nodes contained in the forward_t
 *    structure inside the header of the message.  If timeout is
 *    zero, a default timeout is used. The 'resp' is the actual message
 *    received and contains the ret_list of it's childern and the
 *    forward_structure_t containing information about it's childern
 *    also. Memory is allocated for the returned msg and the returned 
 *    list both must be freed at some point using the
 *    slurm_free_functions and list_destroy function.
 *
 * IN open_fd     - file descriptor to receive msg on
 * OUT resp - a slurm_msg struct to be filled in by the function
 * IN timeout     - how long to wait in milliseconds
 * RET int  - returns 0 on success, -1 on failure and sets errno
 */
int slurm_receive_msg_and_forward(slurm_fd fd, slurm_addr *orig_addr, 
                          slurm_msg_t *resp, int timeout);

/**********************************************************************\
 * send message functions
\**********************************************************************/

/* sends a message to an arbitrary node
 *
 * IN open_fd           - file descriptor to send msg on
 * IN msg         - a slurm msg struct to be sent
 * RET int        - size of msg sent in bytes
 */
int slurm_send_node_msg(slurm_fd open_fd, slurm_msg_t *msg);

/**********************************************************************\
 * msg connection establishment functions used by msg clients
\**********************************************************************/

/* calls connect to make a connection-less datagram connection to the 
 *    primary or secondary slurmctld message engine
 * OUT addr     - address of controller contacted
 * RET slurm_fd   - file descriptor of the connection created
 * IN dest  - controller to contact, primary or secondary
 */
slurm_fd inline slurm_open_controller_conn(slurm_addr *addr);
slurm_fd inline slurm_open_controller_conn_spec(enum controller_id dest);
/* gets the slurm_addr of the specified controller
 *    primary or secondary slurmctld message engine
 * IN dest      - controller to contact, primary or secondary
 * OUT addr     - slurm_addr to the specified controller
 */
void slurm_get_controller_addr_spec(enum controller_id dest, slurm_addr *addr);

/* In the bsd socket implementation it creates a SOCK_STREAM socket  
 *    and calls connect on it a SOCK_DGRAM socket called with connect   
 *    is defined to only receive messages from the address/port pair  
 *    argument of the connect call slurm_address - for now it is  
 *    really just a sockaddr_in
 * IN slurm_address     - slurm_addr of the connection destination
 * RET slurm_fd         - file descriptor of the connection created
 */
slurm_fd inline slurm_open_msg_conn(slurm_addr * slurm_address);

/* just calls close on an established msg connection to close
 * IN open_fd     - an open file descriptor to close
 * RET int  - the return code
 */
int inline slurm_shutdown_msg_conn(slurm_fd open_fd);


/**********************************************************************\
 * stream functions
\**********************************************************************/

/* slurm_listen_stream
 * opens a stream server and listens on it
 * IN slurm_address     - slurm_addr to bind the server stream to
 * RET slurm_fd         - file descriptor of the stream created
 */
slurm_fd inline slurm_listen_stream(slurm_addr * slurm_address);

/* slurm_accept_stream
 * accepts a incomming stream connection on a stream server slurm_fd 
 * IN open_fd           - file descriptor to accept connection on
 * OUT slurm_address    - slurm_addr of the accepted connection
 * RET slurm_fd         - file descriptor of the accepted connection 
 */
slurm_fd inline slurm_accept_stream(slurm_fd open_fd,
                            slurm_addr * slurm_address);

/* slurm_open_stream
 * opens a client connection to stream server
 * IN slurm_address     - slurm_addr of the connection destination
 * RET slurm_fd         - file descriptor of the connection created
 */
slurm_fd inline slurm_open_stream(slurm_addr * slurm_address);

/* slurm_close_stream
 * closes either a server or client stream file_descriptor
 * IN open_fd     - an open file descriptor to close
 * RET int  - the return code
 */
int inline slurm_close_stream(slurm_fd open_fd);

/* slurm_write_stream
 * writes a buffer out a stream file descriptor
 * IN open_fd           - file descriptor to write on
 * IN buffer            - buffer to send
 * IN size        - size of buffer send
 * IN timeout           - how long to wait in milliseconds
 * RET size_t           - bytes sent , or -1 on errror
 */
size_t inline slurm_write_stream(slurm_fd open_fd, char *buffer,
                         size_t size);
size_t inline slurm_write_stream_timeout(slurm_fd open_fd,
                               char *buffer, size_t size,
                               int timeout);

/* slurm_read_stream
 * read into buffer grom a stream file descriptor
 * IN open_fd           - file descriptor to read from
 * OUT buffer     - buffer to receive into
 * IN size        - size of buffer
 * IN timeout           - how long to wait in milliseconds
 * RET size_t           - bytes read , or -1 on errror
 */
size_t inline slurm_read_stream(slurm_fd open_fd, char *buffer,
                        size_t size);
size_t inline slurm_read_stream_timeout(slurm_fd open_fd,
                              char *buffer, size_t size,
                              int timeout);

/* slurm_get_stream_addr
 * esentially a encapsilated get_sockname  
 * IN open_fd           - file descriptor to retreive slurm_addr for
 * OUT address          - address that open_fd to bound to
 */
int inline slurm_get_stream_addr(slurm_fd open_fd, slurm_addr * address);

/* make an open slurm connection blocking or non-blocking
 *    (i.e. wait or do not wait for i/o completion )
 * IN open_fd     - an open file descriptor to change the effect
 * RET int  - the return code
 */
int inline slurm_set_stream_non_blocking(slurm_fd open_fd);
int inline slurm_set_stream_blocking(slurm_fd open_fd);

/**********************************************************************\
 * address conversion and management functions
\**********************************************************************/

/* slurm_set_addr_uint
 * initializes the slurm_address with the supplied port and ip_address
 * OUT slurm_address    - slurm_addr to be filled in
 * IN port        - port in host order
 * IN ip_address  - ipv4 address in uint32 host order form
 */
void inline slurm_set_addr_uint(slurm_addr * slurm_address,
                        uint16_t port, uint32_t ip_address);

/* reset_slurm_addr
 * resets the address field of a slurm_addr, port and family unchanged
 * OUT slurm_address    - slurm_addr to be reset in
 * IN new_address - source of address to write into slurm_address
 */
void reset_slurm_addr(slurm_addr * slurm_address, slurm_addr new_address);

/* slurm_set_addr
 * initializes the slurm_address with the supplied port and ip_address
 * OUT slurm_address    - slurm_addr to be filled in
 * IN port        - port in host order
 * IN host        - hostname or dns name 
 */
void inline slurm_set_addr(slurm_addr * slurm_address,
                     uint16_t port, char *host);

/* slurm_set_addr_any
 * initialized the slurm_address with the supplied port on INADDR_ANY
 * OUT slurm_address    - slurm_addr to be filled in
 * IN port        - port in host order
 */
void inline slurm_set_addr_any(slurm_addr * slurm_address, uint16_t port);

/* slurm_set_addr_char
 * initializes the slurm_address with the supplied port and host
 * OUT slurm_address    - slurm_addr to be filled in
 * IN port        - port in host order
 * IN host        - hostname or dns name 
 */
void inline slurm_set_addr_char(slurm_addr * slurm_address,
                        uint16_t port, char *host);

/* slurm_get_addr 
 * given a slurm_address it returns to port and hostname
 * IN slurm_address     - slurm_addr to be queried
 * OUT port       - port number
 * OUT host       - hostname
 * IN buf_len           - length of hostname buffer
 */
void inline slurm_get_addr(slurm_addr * slurm_address,
                     uint16_t * port, char *host, uint32_t buf_len);

/* slurm_get_ip_str 
 * given a slurm_address it returns its port and ip address string
 * IN slurm_address     - slurm_addr to be queried
 * OUT port       - port number
 * OUT ip         - ip address in dotted-quad string form
 * IN buf_len           - length of ip buffer
 */
void inline slurm_get_ip_str(slurm_addr * slurm_address, uint16_t * port,
                       char *ip, unsigned int buf_len);

/* slurm_get_peer_addr
 * get the slurm address of the peer connection, similar to getpeeraddr
 * IN fd          - an open connection
 * OUT slurm_address    - place to park the peer's slurm_addr
 */
int inline slurm_get_peer_addr(slurm_fd fd, slurm_addr * slurm_address);

/* slurm_print_slurm_addr
 * prints a slurm_addr into a buf
 * IN address           - slurm_addr to print
 * IN buf         - space for string representation of slurm_addr
 * IN n                 - max number of bytes to write (including NUL)
 */
void inline slurm_print_slurm_addr(slurm_addr * address,
                           char *buf, size_t n);

/**********************************************************************\
 * slurm_addr pack routines
\**********************************************************************/

Buf slurm_pack_msg_no_header(slurm_msg_t * msg);

/* slurm_pack_slurm_addr
 * packs a slurm_addr into a buffer to serialization transport
 * IN slurm_address     - slurm_addr to pack
 * IN/OUT buffer  - buffer to pack the slurm_addr into
 */
void inline slurm_pack_slurm_addr(slurm_addr * slurm_address, Buf buffer);

/* slurm_pack_slurm_addr
 * unpacks a buffer into a slurm_addr after serialization transport
 * OUT slurm_address    - slurm_addr to unpack to
 * IN/OUT buffer  - buffer to upack the slurm_addr from
 * returns        - SLURM error code
 */
int inline slurm_unpack_slurm_addr_no_alloc(slurm_addr * slurm_address,
                                  Buf buffer);

/* slurm_pack_slurm_addr_array
 * packs an array of slurm_addrs into a buffer
 * OUT slurm_address    - slurm_addr to pack
 * IN size_val    - how many to pack
 * IN/OUT buffer  - buffer to pack the slurm_addr from
 * returns        - SLURM error code
 */
void inline slurm_pack_slurm_addr_array(slurm_addr * slurm_address,
                              uint16_t size_val, Buf buffer);
/* slurm_unpack_slurm_addr_array
 * unpacks an array of slurm_addrs from a buffer
 * OUT slurm_address    - slurm_addr to unpack to
 * IN size_val    - how many to unpack
 * IN/OUT buffer  - buffer to upack the slurm_addr from
 * returns        - SLURM error code
 */
int inline slurm_unpack_slurm_addr_array(slurm_addr ** slurm_address,
                               uint16_t * size_val, Buf buffer);

/**********************************************************************\
 * simplified communication routines 
 * They open a connection do work then close the connection all within 
 * the function
\**********************************************************************/

/* slurm_send_rc_msg
 * given the original request message this function sends a 
 *    slurm_return_code message back to the client that made the request
 * IN request_msg - slurm_msg the request msg
 * IN rc          - the return_code to send back to the client
 */
int slurm_send_rc_msg(slurm_msg_t * request_msg, int rc);

/* slurm_send_recv_controller_msg
 * opens a connection to the controller, sends the controller a message, 
 * listens for the response, then closes the connection
 * IN request_msg - slurm_msg request
 * OUT response_msg     - slurm_msg response
 * RET int        - returns 0 on success, -1 on failure and sets errno
 */
int slurm_send_recv_controller_msg(slurm_msg_t * request_msg,
                           slurm_msg_t * response_msg);

/* slurm_send_recv_node_msg
 * opens a connection to node,
 * and sends the nodes a message, listens 
 * for the response, then closes the connections
 * IN request_msg - slurm_msg request
 * OUT response_msg     - slurm_msg response
 * RET int        - returns 0 on success, -1 on failure and sets errno
 */
int slurm_send_recv_node_msg(slurm_msg_t * request_msg, 
                       slurm_msg_t * response_msg, 
                       int timeout);

/*
 *  Send a message to the nodelist specificed using fanout
 *    Then return List containing type (ret_data_info_t).
 * IN nodelist        - list of nodes to send to.
 * IN msg           - a slurm_msg struct to be sent by the function
 * IN timeout         - how long to wait in milliseconds
 * RET List     - List containing the responses of the childern
 *                    (if any) we forwarded the message to. List
 *                    containing type (ret_types_t).
 */
List slurm_send_recv_msgs(const char *nodelist, slurm_msg_t *msg, int timeout);

/*
 *  Send a message to msg->address
 *    Then return List containing type (ret_data_info_t). 
 * IN msg           - a slurm_msg struct to be sent by the function
 * IN name          - the name of the node the message is being sent to
 * IN timeout         - how long to wait in milliseconds
 * RET List     - List containing the responses of the childern
 *                    (if any) we forwarded the message to. List
 *                    containing type (ret_types_t).
 */
List slurm_send_addr_recv_msgs(slurm_msg_t *msg, char *name, int timeout);

/*
 *  Same as above, but only to one node 
 *  returns 0 on success, -1 on failure and sets errno
 */

int slurm_send_recv_rc_msg_only_one(slurm_msg_t *req, int *rc, int timeout);

/*
 *  Same as above, but send to controller
 *  returns 0 on success, -1 on failure and sets errno
 */
int slurm_send_recv_controller_rc_msg(slurm_msg_t *req, int *rc);

/* slurm_send_only_controller_msg
 * opens a connection to the controller, sends the node a message then, 
 * closes the connection
 * IN request_msg - slurm_msg request
 * RET int        - return code
 */
int slurm_send_only_controller_msg(slurm_msg_t * request_msg);

/* slurm_send_only_node_msg
 * opens a connection to node, sends the node a message then, 
 * closes the connection
 * IN request_msg - slurm_msg request
 * RET int        - return code
 */
int slurm_send_only_node_msg(slurm_msg_t * request_msg);

/* Slurm message functions */

/* set_span
 * build an array indicating how message fanout should occur
 * IN total - total number of nodes to communicate with
 * IN tree_width - message fanout, use system default if zero
 * NOTE: Returned array MUST be release by caller using xfree */
extern int *set_span(int total, uint16_t tree_width);

extern void slurm_free_msg(slurm_msg_t * msg);

/* must free this memory with free not xfree */
extern char *nodelist_nth_host(const char *nodelist, int inx);
extern int nodelist_find(const char *nodelist, const char *name);
extern void convert_num_unit(float num, char *buf, int buf_size, int orig_type);
extern int revert_num_unit(const char *buf);

/*
 * slurm_job_step_create - Ask the slurm controller for a new job step
 *    credential.
 * IN slurm_step_alloc_req_msg - description of job step request
 * OUT slurm_step_alloc_resp_msg - response to request
 * RET 0 on success, otherwise return -1 and set errno to indicate the error
 * NOTE: free the response using slurm_free_job_step_create_response_msg
 */
extern int slurm_job_step_create (
      job_step_create_request_msg_t *slurm_step_alloc_req_msg, 
      job_step_create_response_msg_t **slurm_step_alloc_resp_msg);
#endif

Generated by  Doxygen 1.6.0   Back to index