/*
* pack_all_front_end - dump all front_end node information for all nodes
* in machine independent form (for network transmission)
* OUT buffer_ptr - pointer to the stored data
* OUT buffer_size - set to size of the buffer in bytes
* IN protocol_version - slurm protocol version of client
* NOTE: the caller must xfree the buffer at *buffer_ptr
* NOTE: READ lock_slurmctld config before entry
*/
extern void pack_all_front_end(char **buffer_ptr, int *buffer_size, uid_t uid,
uint16_t protocol_version)
{
time_t now = time(NULL);
uint32_t nodes_packed = 0;
Buf buffer;
#ifdef HAVE_FRONT_END
uint32_t tmp_offset;
front_end_record_t *front_end_ptr;
int i;
buffer_ptr[0] = NULL;
*buffer_size = 0;
buffer = init_buf(BUF_SIZE * 2);
nodes_packed = 0;
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
/* write header: count and time */
pack32(nodes_packed, buffer);
pack_time(now, buffer);
/* write records */
for (i = 0, front_end_ptr = front_end_nodes;
i < front_end_node_cnt; i++, front_end_ptr++) {
xassert(front_end_ptr->magic == FRONT_END_MAGIC);
_pack_front_end(front_end_ptr, buffer,
protocol_version);
nodes_packed++;
}
} else {
error("pack_all_front_end: Unsupported slurm version %u",
protocol_version);
}
tmp_offset = get_buf_offset (buffer);
set_buf_offset(buffer, 0);
pack32(nodes_packed, buffer);
set_buf_offset(buffer, tmp_offset);
*buffer_size = get_buf_offset(buffer);
buffer_ptr[0] = xfer_buf_data(buffer);
#else
buffer_ptr[0] = NULL;
*buffer_size = 0;
buffer = init_buf(64);
pack32(nodes_packed, buffer);
pack_time(now, buffer);
*buffer_size = get_buf_offset(buffer);
buffer_ptr[0] = xfer_buf_data(buffer);
#endif
}
extern int slurm_persist_conn_process_msg(slurm_persist_conn_t *persist_conn,
persist_msg_t *persist_msg,
char *msg_char, uint32_t msg_size,
Buf *out_buffer, bool first)
{
int rc;
Buf recv_buffer = NULL;
char *comment = NULL;
/* puts msg_char into buffer struct */
recv_buffer = create_buf(msg_char, msg_size);
memset(persist_msg, 0, sizeof(persist_msg_t));
rc = slurm_persist_msg_unpack(persist_conn, persist_msg, recv_buffer);
xfer_buf_data(recv_buffer); /* delete in_buffer struct
* without xfree of msg_char
* (done later in this
* function). */
if (rc != SLURM_SUCCESS) {
comment = xstrdup_printf("Failed to unpack %s message",
slurmdbd_msg_type_2_str(
persist_msg->msg_type, true));
error("CONN:%u %s", persist_conn->fd, comment);
*out_buffer = slurm_persist_make_rc_msg(
persist_conn, rc, comment, persist_msg->msg_type);
xfree(comment);
}
/* 2 versions after 17.02 code refering to DBD_INIT can be removed as it
will no longer be suppported.
*/
else if (first &&
(persist_msg->msg_type != REQUEST_PERSIST_INIT) &&
(persist_msg->msg_type != DBD_INIT)) {
comment = "Initial RPC not REQUEST_PERSIST_INIT";
error("CONN:%u %s type (%d)",
persist_conn->fd, comment, persist_msg->msg_type);
rc = EINVAL;
*out_buffer = slurm_persist_make_rc_msg(
persist_conn, rc, comment,
REQUEST_PERSIST_INIT);
} else if (!first &&
((persist_msg->msg_type == REQUEST_PERSIST_INIT) ||
(persist_msg->msg_type == DBD_INIT))) {
comment = "REQUEST_PERSIST_INIT sent after connection established";
error("CONN:%u %s", persist_conn->fd, comment);
rc = EINVAL;
*out_buffer = slurm_persist_make_rc_msg(
persist_conn, rc, comment, REQUEST_PERSIST_INIT);
}
return rc;
}
/*
* pack_all_part - dump all partition information for all partitions in
* machine independent form (for network transmission)
* OUT buffer_ptr - the pointer is set to the allocated buffer.
* OUT buffer_size - set to size of the buffer in bytes
* IN show_flags - partition filtering options
* IN uid - uid of user making request (for partition filtering)
* global: part_list - global list of partition records
* NOTE: the buffer at *buffer_ptr must be xfreed by the caller
* NOTE: change slurm_load_part() in api/part_info.c if data format changes
*/
extern void pack_all_part(char **buffer_ptr, int *buffer_size,
uint16_t show_flags, uid_t uid,
uint16_t protocol_version)
{
ListIterator part_iterator;
struct part_record *part_ptr;
uint32_t parts_packed;
int tmp_offset;
Buf buffer;
time_t now = time(NULL);
buffer_ptr[0] = NULL;
*buffer_size = 0;
buffer = init_buf(BUF_SIZE);
/* write header: version and time */
parts_packed = 0;
pack32(parts_packed, buffer);
pack_time(now, buffer);
/* write individual partition records */
part_iterator = list_iterator_create(part_list);
while ((part_ptr = (struct part_record *) list_next(part_iterator))) {
xassert (part_ptr->magic == PART_MAGIC);
if (((show_flags & SHOW_ALL) == 0) && (uid != 0) &&
((part_ptr->flags & PART_FLAG_HIDDEN)
|| (validate_group (part_ptr, uid) == 0)))
continue;
pack_part(part_ptr, buffer, protocol_version);
parts_packed++;
}
list_iterator_destroy(part_iterator);
/* put the real record count in the message body header */
tmp_offset = get_buf_offset(buffer);
set_buf_offset(buffer, 0);
pack32(parts_packed, buffer);
set_buf_offset(buffer, tmp_offset);
*buffer_size = get_buf_offset(buffer);
buffer_ptr[0] = xfer_buf_data(buffer);
}
/* Pack all scheduling statistics */
extern void pack_all_stat(int resp, char **buffer_ptr, int *buffer_size,
uint16_t protocol_version)
{
Buf buffer;
int parts_packed;
int agent_queue_size;
time_t now = time(NULL);
buffer_ptr[0] = NULL;
*buffer_size = 0;
buffer = init_buf(BUF_SIZE);
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
parts_packed = resp;
pack32(parts_packed, buffer);
if (resp) {
pack_time(now, buffer);
debug3("pack_all_stat: time = %u",
(uint32_t) last_proc_req_start);
pack_time(last_proc_req_start, buffer);
debug3("pack_all_stat: server_thread_count = %u",
slurmctld_config.server_thread_count);
pack32(slurmctld_config.server_thread_count, buffer);
agent_queue_size = retry_list_size();
pack32(agent_queue_size, buffer);
pack32(slurmctld_diag_stats.jobs_submitted, buffer);
pack32(slurmctld_diag_stats.jobs_started, buffer);
pack32(slurmctld_diag_stats.jobs_completed, buffer);
pack32(slurmctld_diag_stats.jobs_canceled, buffer);
pack32(slurmctld_diag_stats.jobs_failed, buffer);
pack32(slurmctld_diag_stats.schedule_cycle_max,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_last,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_sum,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_counter,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_depth,
buffer);
pack32(slurmctld_diag_stats.schedule_queue_len, buffer);
pack32(slurmctld_diag_stats.backfilled_jobs, buffer);
pack32(slurmctld_diag_stats.last_backfilled_jobs,
buffer);
pack32(slurmctld_diag_stats.bf_cycle_counter, buffer);
pack32(slurmctld_diag_stats.bf_cycle_sum, buffer);
pack32(slurmctld_diag_stats.bf_cycle_last, buffer);
pack32(slurmctld_diag_stats.bf_last_depth, buffer);
pack32(slurmctld_diag_stats.bf_last_depth_try, buffer);
pack32(slurmctld_diag_stats.bf_queue_len, buffer);
pack32(slurmctld_diag_stats.bf_cycle_max, buffer);
pack_time(slurmctld_diag_stats.bf_when_last_cycle,
buffer);
pack32(slurmctld_diag_stats.bf_depth_sum, buffer);
pack32(slurmctld_diag_stats.bf_depth_try_sum, buffer);
pack32(slurmctld_diag_stats.bf_queue_len_sum, buffer);
pack32(slurmctld_diag_stats.bf_active, buffer);
}
}
*buffer_size = get_buf_offset(buffer);
buffer_ptr[0] = xfer_buf_data(buffer);
}
int main (int argc, char *argv[])
{
Buf buffer;
uint16_t test16 = 1234, out16;
uint32_t test32 = 5678, out32, byte_cnt;
char testbytes[] = "TEST BYTES", *outbytes;
char teststring[] = "TEST STRING", *outstring = NULL;
char *nullstr = NULL;
char *data;
int data_size;
long double test_double = 1340664754944.2132312, test_double2;
uint64_t test64;
buffer = init_buf (0);
pack16(test16, buffer);
pack32(test32, buffer);
pack64((uint64_t)test_double, buffer);
packstr(testbytes, buffer);
packstr(teststring, buffer);
packstr(nullstr, buffer);
packstr("literal", buffer);
packstr("", buffer);
data_size = get_buf_offset(buffer);
printf("wrote %d bytes\n", data_size);
/* Pull data off old buffer, destroy it, and create a new one */
data = xfer_buf_data(buffer);
buffer = create_buf(data, data_size);
unpack16(&out16, buffer);
TEST(out16 != test16, "un/pack16");
unpack32(&out32, buffer);
TEST(out32 != test32, "un/pack32");
unpack64(&test64, buffer);
test_double2 = (long double)test64;
TEST((uint64_t)test_double2 != (uint64_t)test_double, "un/pack double as a uint64");
/* info("Original\t %Lf", test_double); */
/* info("uint64\t %ld", test64); */
/* info("converted LD\t %Lf", test_double2); */
unpackstr_ptr(&outbytes, &byte_cnt, buffer);
TEST( ( strcmp(testbytes, outbytes) != 0 ) , "un/packstr_ptr");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp(teststring, outstring) != 0, "un/packstr_xmalloc");
xfree(outstring);
unpackstr_xmalloc(&nullstr, &byte_cnt, buffer);
TEST(nullstr != NULL, "un/packstr of null string.");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("literal", outstring) != 0,
"un/packstr of string literal");
xfree(outstring);
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("", outstring) != 0, "un/packstr of string \"\" ");
xfree(outstring);
free_buf(buffer);
totals();
return failed;
}
