Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: develop
Fetching contributors…

Cannot retrieve contributors at this time

923 lines (769 sloc) 23.887 kB
/*****************************************************************************\
* slurm_php.c - php interface to slurm.
*
*****************************************************************************
* Copyright (C) 2011 - Trinity Centre for High Performance Computing
* Copyright (C) 2011 - Trinity College Dublin
* Written By : Vermeulen Peter <HoWest><Belgium>
*
* This file is part of php-slurm, a resource management program.
* Please also read the included file: DISCLAIMER.
*
* php-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.
*
* php-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 php-slurm; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
\*****************************************************************************/
/*****************************************************************************\
*
* Documentation for each function can be found in the slurm_php.h file
*
\*****************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "slurm_php.h"
static function_entry slurm_functions[] = {
PHP_FE(slurm_ping, NULL)
PHP_FE(slurm_slurmd_status, NULL)
PHP_FE(slurm_print_partition_names, NULL)
PHP_FE(slurm_get_specific_partition_info, NULL)
PHP_FE(slurm_get_partition_node_names, NULL)
PHP_FE(slurm_version, NULL)
PHP_FE(slurm_get_node_names, NULL)
PHP_FE(slurm_get_node_elements, NULL)
PHP_FE(slurm_get_node_element_by_name, NULL)
PHP_FE(slurm_get_node_state_by_name, NULL)
PHP_FE(slurm_get_control_configuration_keys, NULL)
PHP_FE(slurm_get_control_configuration_values, NULL)
PHP_FE(slurm_load_job_information, NULL)
PHP_FE(slurm_load_partition_jobs, NULL)
PHP_FE(slurm_get_node_states, NULL)
PHP_FE(slurm_hostlist_to_array, NULL)
PHP_FE(slurm_array_to_hostlist, NULL) {
NULL, NULL, NULL
}
};
zend_module_entry slurm_php_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
SLURM_PHP_EXTNAME,
slurm_functions,
NULL,
NULL,
NULL,
NULL,
NULL,
#if ZEND_MODULE_API_NO >= 20010901
SLURM_PHP_VERSION,
#endif
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_SLURM_PHP
ZEND_GET_MODULE(slurm_php)
#endif
#ifdef HAVE_XMALLOC_H
#define malloc(size) xmalloc(size)
#define free(ptr) xfree(ptr)
#endif
/*****************************************************************************\
* HELPER FUNCTION PROTOTYPES
\*****************************************************************************/
/*
* _parse_node_pointer - Parse a node pointer's contents into an
* assocative zval array where the key is descriptive to the
* value
*
* IN sub_arr - array to store the contents of the node pointer
* IN node_arr - node pointer that needs parsing
*/
static void _parse_node_pointer(zval *sub_arr, node_info_t *node_arr);
/*
* _parse_assoc_array - Parse a character array where the elements are
* key-value pairs separated by delimiters into an associative
* array
*
* IN char_arr - character array that needs parsing
* IN delims - character array that contains the delimeters used in parsing
* IN result_arr - associative array used to store the key_value pairs in
*/
static void _parse_assoc_array(char *char_arr, char *delims, zval *result_arr);
/*
* _parse_array - Parse a character array where the elements are values
* separated by delimiters into a numerically indexed array
*
* IN char_arr - character array that needs parsing
* IN delims - character array that contains the delimeters used in parsing
* IN result_arr - numerically indexed array used to store the values in
*/
static void _parse_array(char *char_arr, char *delims, zval *rslt_arr);
/*
* _zend_add_valid_assoc_string - checks a character array to see if
* it's NULL or not, if so an associative null is added, if not
* an associative string is added.
*
* IN rstl_arr - array to store the associative key_value pairs in
* IN key - character array used as the associative key
* IN val - character array to be validated and added as value if valid
*/
static void _zend_add_valid_assoc_string(zval *rstl_arr, char *key, char *val);
/*
* _zend_add_valid_assoc_time_string - checks a unix timestamp to see if it's
* 0 or not, if so an associative null is added, if not a formatted string
* is added.
*
* IN rstl_arr - array to store the associative key_value pairs in
* IN key - character array used as the associative key
* IN val - time_t unix timestamp to be validated and added if valid
* NOTE : If you'd like to change the format in which the valid strings are
* returned, you can change the TIME_FORMAT_STRING macro to the needed format
*/
static void _zend_add_valid_assoc_time_string(
zval *rstl_arr, char *key, time_t *val);
/*****************************************************************************\
* TODO
*****************************************************************************
* [ADJUSTING EXISTING FUNCTIONS]
* - _parse_node_pointer
* dynamic_plugin_data_t is currently not returned
* [EXTRA FUNCTIONS]
* - Functions that filter jobs on the nodes they are running on
* - Scheduling
* - ...
\*****************************************************************************/
/*****************************************************************************\
* HELPER FUNCTIONS
\*****************************************************************************/
static void _parse_node_pointer(zval *sub_arr, node_info_t *node_arr)
{
zval *sub_arr_2 = NULL;
_zend_add_valid_assoc_string(sub_arr, "Name", node_arr->name);
_zend_add_valid_assoc_string(sub_arr, "Arch.", node_arr->arch);
_zend_add_valid_assoc_time_string(sub_arr, "Boot Time",
&node_arr->boot_time);
add_assoc_long(sub_arr, "#CPU'S", node_arr->cpus);
add_assoc_long(sub_arr, "#Cores/CPU", node_arr->cores);
if (node_arr->features == NULL) {
add_assoc_null(sub_arr, "Features");
} else {
ALLOC_INIT_ZVAL(sub_arr_2);
array_init(sub_arr_2);
_parse_array(node_arr->features, ",", sub_arr_2);
add_assoc_zval(sub_arr, "Features", sub_arr_2);
}
_zend_add_valid_assoc_string(sub_arr, "GRES", node_arr->gres);
add_assoc_long(sub_arr, "State", node_arr->node_state);
_zend_add_valid_assoc_string(sub_arr, "OS", node_arr->os);
add_assoc_long(sub_arr, "Real Mem", node_arr->real_memory);
if (node_arr->reason!=NULL) {
_zend_add_valid_assoc_string(sub_arr, "Reason",
node_arr->reason);
_zend_add_valid_assoc_time_string(sub_arr,"Reason Timestamp",
&node_arr->reason_time);
add_assoc_long(sub_arr, "Reason User Id",
node_arr->reason_uid);
} else {
add_assoc_null(sub_arr, "Reason");
add_assoc_null(sub_arr, "Reason Timestamp");
add_assoc_null(sub_arr, "Reason User Id");
}
_zend_add_valid_assoc_time_string(sub_arr, "Slurmd Startup Time",
&node_arr->slurmd_start_time);
add_assoc_long(sub_arr, "#Sockets/Node", node_arr->sockets);
add_assoc_long(sub_arr, "#Threads/Core", node_arr->threads);
add_assoc_long(sub_arr, "TmpDisk", node_arr->tmp_disk);
add_assoc_long(sub_arr, "Weight", node_arr->weight);
}
static void _parse_assoc_array(char *char_arr, char *delims, zval *result_arr)
{
char *rslt = NULL;
char *tmp = NULL;
int i = 0;
rslt = strtok(char_arr, delims);
while (rslt != NULL) {
if (i == 0) {
tmp = rslt;
} else if (i == 1) {
if (strcmp(rslt,"(null)")==0) {
add_assoc_null(result_arr, tmp);
} else {
_zend_add_valid_assoc_string(result_arr,
tmp, rslt);
}
}
i++;
if (i == 2) {
i = 0;
}
rslt = strtok(NULL, delims);
}
}
static void _parse_array(char *char_arr, char *delims, zval *rslt_arr)
{
char *rslt = NULL;
char *tmp = NULL;
rslt = strtok(char_arr, delims);
while (rslt != NULL) {
if (strcmp(rslt, "(null)")==0) {
add_next_index_null(rslt_arr);
} else {
tmp = slurm_xstrdup(rslt);
add_next_index_string(rslt_arr, tmp, 1);
}
rslt = strtok(NULL, delims);
}
}
static void _zend_add_valid_assoc_string(zval *rstl_arr, char *key, char *val)
{
char *tmp = NULL;
if (!val)
add_assoc_null(rstl_arr, key);
else {
tmp = slurm_xstrdup(val);
add_assoc_string(rstl_arr, key, tmp, 1);
}
}
static void _zend_add_valid_assoc_time_string(
zval *rstl_arr, char *key, time_t *val)
{
char buf[80];
struct tm *timeinfo;
if (val==0) {
add_assoc_null(rstl_arr, key);
} else {
timeinfo = localtime(val);
strftime(buf, 80, TIME_FORMAT_STRING, timeinfo);
add_assoc_string(rstl_arr, key, buf, 1);
}
}
/*****************************************************************************\
* SLURM STATUS FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_ping)
{
int err = SLURM_SUCCESS;
array_init(return_value);
err = slurm_ping(1);
add_assoc_long(return_value,"Prim. Controller",err);
err = slurm_ping(2);
add_assoc_long(return_value,"Sec. Controller",err);
}
PHP_FUNCTION(slurm_slurmd_status)
{
int err = SLURM_SUCCESS;
slurmd_status_t *status_ptr = NULL;
err = slurm_load_slurmd_status(&status_ptr);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
_zend_add_valid_assoc_time_string(return_value,"Booted_at",
&status_ptr->booted);
_zend_add_valid_assoc_time_string(return_value,"Last_Msg",
&status_ptr->last_slurmctld_msg);
add_assoc_long(return_value,"Logging_Level", status_ptr->slurmd_debug);
add_assoc_long(return_value,"Actual_CPU's", status_ptr->actual_cpus);
add_assoc_long(return_value,"Actual_Sockets",
status_ptr->actual_sockets);
add_assoc_long(return_value,"Actual_Cores",status_ptr->actual_cores);
add_assoc_long(return_value,"Actual_Threads",
status_ptr->actual_threads);
add_assoc_long(return_value,"Actual_Real_Mem",
status_ptr->actual_real_mem);
add_assoc_long(return_value,"Actual_Tmp_Disk",
status_ptr->actual_tmp_disk);
add_assoc_long(return_value,"PID",status_ptr->pid);
_zend_add_valid_assoc_string(return_value, "Hostname",
status_ptr->hostname);
_zend_add_valid_assoc_string(return_value, "Slurm Logfile",
status_ptr->slurmd_logfile);
_zend_add_valid_assoc_string(return_value, "Step List",
status_ptr->step_list);
_zend_add_valid_assoc_string(return_value, "Version",
status_ptr->version);
if (status_ptr != NULL) {
slurm_free_slurmd_status(status_ptr);
}
}
PHP_FUNCTION(slurm_version)
{
long option = -1;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC,
"l", &option) == FAILURE) {
RETURN_LONG(-3);
}
switch (option) {
case 0:
RETURN_LONG(SLURM_VERSION_MAJOR(SLURM_VERSION_NUMBER));
break;
case 1:
RETURN_LONG(SLURM_VERSION_MINOR(SLURM_VERSION_NUMBER));
break;
case 2:
RETURN_LONG(SLURM_VERSION_MICRO(SLURM_VERSION_NUMBER));
break;
default:
array_init(return_value);
add_next_index_long(return_value,
SLURM_VERSION_MAJOR(SLURM_VERSION_NUMBER));
add_next_index_long(return_value,
SLURM_VERSION_MINOR(SLURM_VERSION_NUMBER));
add_next_index_long(return_value,
SLURM_VERSION_MICRO(SLURM_VERSION_NUMBER));
break;
}
}
/*****************************************************************************\
* SLURM PHP HOSTLIST FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_hostlist_to_array)
{
long lngth = 0;
char *host_list = NULL;
char *name = NULL;
hostlist_t hl = NULL;
int hl_length = 0;
int i=0;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d",
&host_list, &lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((host_list == NULL) || !strcmp(host_list, "")) {
RETURN_LONG(-3);
}
hl = slurm_hostlist_create(host_list);
hl_length = slurm_hostlist_count(hl);
if (hl_length==0) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i=0; i<hl_length; i++) {
name = slurm_hostlist_shift(hl);
add_next_index_string(return_value, name, 1);
}
}
PHP_FUNCTION(slurm_array_to_hostlist)
{
zval *node_arr = NULL, **data;
hostlist_t hl = NULL;
HashTable *arr_hash;
HashPosition pointer;
int arr_length = 0;
char *buf;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "a",
&node_arr) == FAILURE) {
RETURN_LONG(-3);
}
if (node_arr == NULL) {
RETURN_LONG(-3);
}
arr_hash = Z_ARRVAL_P(node_arr);
arr_length = zend_hash_num_elements(arr_hash);
if (arr_length==0) {
RETURN_LONG(-2);
}
hl = slurm_hostlist_create(NULL);
for (zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
zend_hash_get_current_data_ex(arr_hash, (void**) &data,
&pointer) == SUCCESS;
zend_hash_move_forward_ex(arr_hash, &pointer)) {
if (Z_TYPE_PP(data) == IS_STRING) {
slurm_hostlist_push_host(hl,Z_STRVAL_PP(data));
}
}
array_init(return_value);
buf = slurm_hostlist_ranged_string_xmalloc(hl);
_zend_add_valid_assoc_string(return_value, "HOSTLIST", buf);
}
/*****************************************************************************\
* SLURM PARTITION READ FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_print_partition_names)
{
int err = SLURM_SUCCESS;
int i;
char *tmp = NULL;
partition_info_msg_t *prt_ptr = NULL;
err = slurm_load_partitions((time_t) NULL, &prt_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i = 0; i < prt_ptr->record_count; i++) {
tmp = slurm_xstrdup(prt_ptr->partition_array[i].name);
add_next_index_string(return_value, tmp, 1);
}
slurm_free_partition_info_msg(prt_ptr);
if (i == 0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_specific_partition_info)
{
long lngth = 0;
int err = SLURM_SUCCESS;
partition_info_msg_t *prt_ptr = NULL;
partition_info_t *prt_data = NULL;
char *name = NULL;
char *tmp = NULL;
int i = 0;
int y = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d", &name,
&lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((name == NULL) || !strcmp(name, "")) {
RETURN_LONG(-3);
}
err = slurm_load_partitions((time_t) NULL, &prt_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
if (prt_ptr->record_count != 0) {
for (i = 0; i < prt_ptr->record_count; i++) {
if (strcmp(prt_ptr->partition_array->name, name) == 0) {
prt_data = &prt_ptr->partition_array[i];
tmp = slurm_sprint_partition_info(prt_data, 1);
array_init(return_value);
_parse_assoc_array(tmp, "= ", return_value);
y++;
break;
}
}
}
slurm_free_partition_info_msg(prt_ptr);
if (y == 0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_partition_node_names)
{
char *prt_name = NULL;
char *tmp = NULL;
long lngth = 0;
int err = SLURM_SUCCESS;
partition_info_msg_t *prt_ptr = NULL;
partition_info_t *prt_data = NULL;
int i = 0;
int y = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d", &prt_name,
&lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((prt_name == NULL) || (strcmp(prt_name,"")==0)) {
RETURN_LONG(-3);
}
err = slurm_load_partitions((time_t) NULL, &prt_ptr, 0);
if (err)
RETURN_LONG(-2);
if (prt_ptr->record_count != 0) {
for (i = 0; i < prt_ptr->record_count; i++) {
if (!strcmp(prt_ptr->partition_array->name, prt_name)) {
prt_data = &prt_ptr->partition_array[i];
array_init(return_value);
tmp = slurm_xstrdup(prt_data->nodes);
add_next_index_string(
return_value, tmp, 1);
y++;
break;
}
}
}
slurm_free_partition_info_msg(prt_ptr);
if (y == 0)
RETURN_LONG(-1);
}
/*****************************************************************************\
* SLURM NODE CONFIGURATION READ FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_get_node_names)
{
int err = SLURM_SUCCESS;
int i = 0;
char tmp = NULL;
node_info_msg_t *node_ptr = NULL;
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
if (node_ptr->record_count > 0) {
array_init(return_value);
for (i = 0; i < node_ptr->record_count; i++) {
tmp =
slurm_xstrdup(node_ptr->node_array[i].name);
add_next_index_string(return_value, tmp, 1);
}
}
slurm_free_node_info_msg(node_ptr);
if(i==0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_node_elements)
{
int err = SLURM_SUCCESS;
int i = 0;
char *tmp = NULL;
node_info_msg_t *node_ptr;
zval *sub_arr = NULL;
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
if (node_ptr->record_count > 0) {
array_init(return_value);
for (i = 0; i < node_ptr->record_count; i++) {
ALLOC_INIT_ZVAL(sub_arr);
array_init(sub_arr);
_parse_node_pointer(sub_arr, &node_ptr->node_array[i]);
tmp = slurm_xstrdup_printf("%s", node_ptr->node_array[i].name);
add_assoc_zval(return_value,
tmp,
sub_arr);
}
}
slurm_free_node_info_msg(node_ptr);
if(i==0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_node_element_by_name)
{
int err = SLURM_SUCCESS;
int i = 0,y = 0;
node_info_msg_t *node_ptr;
char *node_name = NULL;
char *tmp = NULL;
long lngth;
zval *sub_arr = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d", &node_name,
&lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((node_name == NULL) || (strcmp(node_name,"")==0)) {
RETURN_LONG(-3);
}
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i = 0; i < node_ptr->record_count; i++) {
if (strcmp(node_ptr->node_array->name, node_name) == 0) {
y++;
ALLOC_INIT_ZVAL(sub_arr);
array_init(sub_arr);
_parse_node_pointer(sub_arr, &node_ptr->node_array[i]);
tmp = slurm_xstrdup(node_name);
add_assoc_zval(return_value, tmp,
sub_arr);
break;
}
}
slurm_free_node_info_msg(node_ptr);
if (y == 0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_node_state_by_name)
{
int err = SLURM_SUCCESS;
int i = 0,y = 0;
node_info_msg_t *node_ptr;
char *node_name = NULL;
long lngth;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d", &node_name,
&lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((node_name == NULL) || (strcmp(node_name,"")==0)) {
RETURN_LONG(-3);
}
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
for (i = 0; i < node_ptr->record_count; i++) {
if (strcmp(node_ptr->node_array->name, node_name) == 0) {
y++;
RETURN_LONG(node_ptr->node_array[i].node_state);
break;
}
}
slurm_free_node_info_msg(node_ptr);
if (i == 0) {
RETURN_LONG(-1);
}
if (y==0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_get_node_states)
{
int err = SLURM_SUCCESS;
int i = 0;
char *tmp = NULL;
node_info_msg_t *node_ptr;
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i = 0; i < node_ptr->record_count; i++) {
tmp = slurm_xstrdup_printf("%u", node_ptr->node_array[i].node_state);
add_next_index_long(return_value,
tmp);
}
slurm_free_node_info_msg(node_ptr);
if (i == 0) {
RETURN_LONG(-1);
}
}
/*****************************************************************************\
* SLURM CONFIGURATION READ FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_get_control_configuration_keys)
{
int err = SLURM_SUCCESS;
char *tmp = NULL;
slurm_ctl_conf_t *ctrl_conf_ptr;
List lst;
ListIterator iter = NULL;
key_pair_t *k_p;
err = slurm_load_ctl_conf((time_t) NULL, &ctrl_conf_ptr);
if (err) {
RETURN_LONG(-2);
}
lst = slurm_ctl_conf_2_key_pairs(ctrl_conf_ptr);
if (!lst) {
RETURN_LONG(-1);
}
iter = slurm_list_iterator_create(lst);
array_init(return_value);
while ((k_p = slurm_list_next(iter))) {
tmp = slurm_xstrdup(k_p->name);
add_next_index_string(return_value, tmp, 1);
}
slurm_free_ctl_conf(ctrl_conf_ptr);
}
PHP_FUNCTION(slurm_get_control_configuration_values)
{
int err = SLURM_SUCCESS;
char *tmp = NULL;
slurm_ctl_conf_t *ctrl_conf_ptr;
List lst;
ListIterator iter = NULL;
key_pair_t *k_p;
err = slurm_load_ctl_conf((time_t) NULL, &ctrl_conf_ptr);
if (err) {
RETURN_LONG(-2);
}
lst = slurm_ctl_conf_2_key_pairs(ctrl_conf_ptr);
if (!lst) {
RETURN_LONG(-1);
}
iter = slurm_list_iterator_create(lst);
array_init(return_value);
while ((k_p = slurm_list_next(iter))) {
if (k_p->value==NULL) {
add_next_index_null(return_value);
} else {
tmp = slurm_xstrdup(k_p->value);
add_next_index_string(return_value, tmp, 1);
}
}
slurm_free_ctl_conf(ctrl_conf_ptr);
}
/*****************************************************************************\
* SLURM JOB READ FUNCTIONS
\*****************************************************************************/
PHP_FUNCTION(slurm_load_job_information)
{
int err = SLURM_SUCCESS;
int i = 0;
job_info_msg_t *job_ptr;
zval *sub_arr = NULL;
char *tmp;
err = slurm_load_jobs((time_t) NULL, &job_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i = 0; i < job_ptr->record_count; i++) {
ALLOC_INIT_ZVAL(sub_arr);
array_init(sub_arr);
_parse_assoc_array(slurm_sprint_job_info(
&job_ptr->job_array[i], 1),
"= ", sub_arr);
tmp = slurm_xstrdup_printf("%u", job_ptr->job_array[i].job_id);
add_assoc_zval(return_value, tmp, sub_arr);
}
slurm_free_job_info_msg(job_ptr);
if (i == 0) {
RETURN_LONG(-1);
}
}
PHP_FUNCTION(slurm_load_partition_jobs)
{
int err = SLURM_SUCCESS;
int i = 0;
job_info_msg_t *job_ptr;
zval *sub_arr = NULL;
char *tmp;
char *pname = NULL;
long lngth;
long checker = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "s|d", &pname,
&lngth) == FAILURE) {
RETURN_LONG(-3);
}
if ((pname == NULL) || !strcmp(pname,"")) {
RETURN_LONG(-3);
}
err = slurm_load_jobs((time_t) NULL, &job_ptr, 0);
if (err) {
RETURN_LONG(-2);
}
array_init(return_value);
for (i = 0; i < job_ptr->record_count; i++) {
if (!strcmp(job_ptr->job_array->partition, pname)) {
checker++;
ALLOC_INIT_ZVAL(sub_arr);
array_init(sub_arr);
_parse_assoc_array(slurm_sprint_job_info(
&job_ptr->job_array[i], 1),
"= ", sub_arr);
tmp = slurm_xstrdup_printf(
"%u", job_ptr->job_array[i].job_id);
add_assoc_zval(return_value, tmp, sub_arr);
}
}
slurm_free_job_info_msg(job_ptr);
if (i == 0) {
RETURN_LONG(-1);
}
if (checker==0) {
RETURN_LONG(-1);
}
}
Jump to Line
Something went wrong with that request. Please try again.