/****** spool/utilities/spool_free_spooling_fields() ********************
* NAME
* spool_free_spooling_fields() -- free a spooling field array
*
* SYNOPSIS
* spooling_field * spool_free_spooling_fields(spooling_field *fields)
*
* FUNCTION
* Frees an array of spooling_field with all sublists and contained strings.
*
* INPUTS
* spooling_field *fields - the field array to free
*
* RESULT
* spooling_field * - NULL
*
* EXAMPLE
* fields = spool_free_spooling_fields(fields);
*******************************************************************************/
spooling_field *
spool_free_spooling_fields(spooling_field *fields)
{
if (fields != NULL) {
int i;
for (i = 0; fields[i].nm >=0; i++) {
if (fields[i].sub_fields != NULL && fields[i].sub_fields != fields) {
fields[i].sub_fields = spool_free_spooling_fields(fields[i].sub_fields);
}
if (fields[i].name != NULL) {
sge_free(&(fields[i].name));
}
}
sge_free(&fields);
}
return NULL;
}
int main(int argc, char *argv[])
{
lListElem *queue, *copy;
const lDescr *descr;
spooling_field *fields;
dstring queue_str = DSTRING_INIT;
dstring copy_str = DSTRING_INIT;
lList *answer_list;
int i;
lInit(nmv);
descr = QU_Type;
copy = lCreateElem(descr);
/* lWriteElemTo(queue, stdout); */
for(i = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
int nm;
const char *name;
const char *value, *reread_value;
nm = descr[i].nm;
name = lNm2Str(nm);
value = object_append_field_to_dstring(queue, &answer_list,
&queue_str, nm, '\0');
reread_value = NULL;
if(value != NULL) {
if(!object_parse_field_from_string(copy, &answer_list, nm, value)) {
fprintf(stderr, "setting value for field %s failed\n", name);
} else {
reread_value = object_append_field_to_dstring(copy, &answer_list,
©_str, nm, '\0');
}
}
#if 1
printf("%s\t%s\t%s\n", name,
value == NULL ? "<null>" : value,
reread_value == NULL ? "<null>" : reread_value);
#endif
if(sge_strnullcmp(value, reread_value) != 0) {
fprintf(stderr, "regression test for object_[gs]et_field_contents failed for attribute "SFQ": "SFQ" != "SFQ"\n",
name,
value != NULL ? value : "<null>",
reread_value != NULL ? reread_value : "<null>");
}
}
fields = spool_get_fields_to_spool(&answer_list, QU_Type, &spool_config_instr);
printf("\nthe following fields will be spooled:");
for(i = 0; fields[i].nm != NoName; i++) {
printf(" %s", lNm2Str(fields[i].nm));
}
printf("\n");
fields = spool_free_spooling_fields(fields);
/* cleanup */
lFreeElem(&queue);
lFreeElem(©);
sge_dstring_free(&queue_str);
sge_dstring_free(©_str);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
lListElem *queue, *copy;
lList *queue_list;
lList *answer_list = NULL;
const lDescr *descr;
spooling_field *fields;
const char *filepath;
int i;
int width;
char format[100];
lInit(nmv);
queue = queue_create_template();
lSetString(queue, QU_terminate_method, "/tmp/myterminate_method.sh");
lAddSubStr(queue, CE_name, "foo", QU_suspend_thresholds, CE_Type);
lAddSubStr(queue, CE_name, "bar", QU_suspend_thresholds, CE_Type);
copy = lCreateElem(QU_Type);
queue_list = lCreateList("queue_list", QU_Type);
lAppendElem(queue_list, queue);
lAppendElem(queue_list, copy);
descr = lGetElemDescr(queue);
fields = spool_get_fields_to_spool(&answer_list, QU_Type, &spool_config_instr);
printf("\nthe following fields are spooled:");
for(i = 0; fields[i].nm != NoName; i++) {
printf(" %s", lNm2Str(fields[i].nm));
}
printf("\n");
spool_flatfile_align_object(&answer_list, fields);
width = fields[0].width;
printf("alignment for attribute names is %d\n", width);
spool_flatfile_align_list(&answer_list, queue_list, fields);
printf("field widths for list output is as follows:\n");
sprintf(format, "%%%ds: %%d\n", width);
for(i = 0; fields[i].nm != NoName; i++) {
printf(format, lNm2Str(fields[i].nm), fields[i].width);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_STDOUT, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
printf("\n");
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_TMP, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("temporary file %s successfully written\n", filepath);
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lListElem *reread_queue;
printf("spool file %s successfully written\n", filepath);
/* reread queue from file */
reread_queue = spool_flatfile_read_object(&answer_list, QU_Type, NULL, NULL,
&spool_flatfile_instr_config,
SP_FORM_ASCII, NULL,
"test_sge_spooling_flatfile.dat");
if(reread_queue == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteElemTo(reread_queue, stdout);
lFreeElem(&reread_queue);
}
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_STDOUT, SP_FORM_ASCII,
NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lList *reread_list;
printf("spool file %s successfully written\n", filepath);
reread_list = spool_flatfile_read_list(&answer_list, QU_Type, NULL, NULL, &spool_flatfile_instr_config_list, SP_FORM_ASCII, NULL, "test_sge_spooling_flatfile.dat");
if (reread_list == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteListTo(reread_list, stdout);
lFreeList(&reread_list);
}
/* sge_unlink(NULL, filepath); */
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
/* test reading object */
/* test nonexisting filename */
/* test behaviour with NULL-pointer passed */
printf("\n\ntesting error handling, the next calls have to fail\n");
spool_flatfile_align_object(&answer_list, NULL);
spool_flatfile_align_list(&answer_list, NULL, fields);
spool_flatfile_align_list(&answer_list, queue_list, NULL);
answer_list_print_err_warn(&answer_list, NULL, NULL);
/* cleanup */
lFreeList(&queue_list);
fields = spool_free_spooling_fields(fields);
fprintf(stdout, "file handle stdout still alive\n");
fprintf(stderr, "file handle stderr still alive\n");
return EXIT_SUCCESS;
}
static spooling_field *
_spool_get_fields_to_spool(lList **answer_list, const lDescr *descr,
const spool_instr *instr)
{
spooling_field *fields;
int i, j, size;
int strip = 0;
DENTER(TOP_LAYER, "_spool_get_fields_to_spool");
/* we don't check descr and instr, as we know they are ok
* (it's a static function)
*/
/* count fields to spool */
for (i = 0, size = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
if ((descr[i].mt & instr->selection) != 0) {
size++;
}
}
/* allocate memory */
fields = (spooling_field *)malloc((size + 1) * sizeof(spooling_field));
if (fields == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_UNABLETOALLOCATEBYTES_DS,
(size * 1) * sizeof(spooling_field), SGE_FUNC);
DRETURN(NULL);
}
/* initialize fields */
for (i = 0; i < size; i++) {
fields[i].nm = NoName;
fields[i].width = 0;
fields[i].name = NULL;
fields[i].sub_fields = NULL;
fields[i].clientdata = NULL;
fields[i].read_func = NULL;
fields[i].write_func = NULL;
}
/* do we have to strip field prefixes, e.g. "QU_" from field names? */
if (instr->copy_field_names && instr->strip_field_prefix) {
dstring buffer = DSTRING_INIT;
const char *prefix = object_get_name_prefix(descr, &buffer);
strip = sge_strlen(prefix);
sge_dstring_free(&buffer);
}
/* copy field info */
for (i = 0, j = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
if ((descr[i].mt & instr->selection) != 0) {
spooling_field *sub_fields = NULL;
DPRINTF(("field "SFQ" will be spooled\n", lNm2Str(descr[i].nm)));
fields[j].nm = descr[i].nm;
if (instr->copy_field_names) {
const char *name;
name = lNm2Str(descr[i].nm);
if(name == NULL || strlen(name) <= strip) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_NONAMEFORATTRIBUTE_D,
descr[i].nm);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
fields[j].name = strdup(name + strip);
}
if (mt_get_type(descr[i].mt) == lListT) {
const lDescr *sub_descr;
if (instr->sub_instr == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_DONTKNOWHOWTOSPOOLSUBLIST_SS,
lNm2Str(descr[i].nm), SGE_FUNC);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
sub_descr = object_get_subtype(descr[i].nm);
if (sub_descr == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_UNKNOWNOBJECTTYPEFOR_SS,
lNm2Str(descr[i].nm), SGE_FUNC);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
/* recursive spooling, e.g. sharetree */
if (instr->sub_instr == instr && descr == sub_descr) {
sub_fields = fields;
DPRINTF(("recursive structure detected for field %s\n",
lNm2Str(descr[i].nm)));
} else {
sub_fields = _spool_get_fields_to_spool(answer_list, sub_descr,
instr->sub_instr);
}
}
fields[j++].sub_fields = sub_fields;
}
}
/* end of field array */
fields[j].nm = NoName;
DEXIT;
return fields;
}
