mirror of https://github.com/BOINC/boinc.git
410 lines
8.0 KiB
C
410 lines
8.0 KiB
C
/* Local variables: */
|
|
/* c-file-style: "linux" */
|
|
/* End: */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "dc.h"
|
|
|
|
/***************************************
|
|
* Definitions
|
|
*/
|
|
|
|
#define TEST_LOW_LVL 1
|
|
#define TEST_HIGH_LVL 2
|
|
#define TEST_ERRORS 3
|
|
#define TEST_STRESS 4
|
|
|
|
/***************************************
|
|
* Global variables
|
|
*/
|
|
|
|
DC_GridCapabilities gc;
|
|
DC_Workunit *wu[10];
|
|
|
|
static int testlevel = 0;
|
|
static int finished = 0;
|
|
|
|
/***************************************
|
|
* Function prototypes
|
|
*/
|
|
|
|
static int init(int argc, char *argv[]);
|
|
static int createWU(void);
|
|
static int submitWU(void);
|
|
static void countWUs(void);
|
|
static void callbackResult(DC_Workunit *wu_result, DC_Result *result);
|
|
static void callbackSubresult(DC_Workunit *wu, const char *label, const char *path);
|
|
static void callbackMessage(DC_Workunit *wu, const char *message);
|
|
|
|
/***************************************
|
|
* Functions
|
|
*/
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int retval;
|
|
|
|
retval = init(argc, argv);
|
|
if (retval)
|
|
return retval;
|
|
|
|
retval = createWU();
|
|
if (retval)
|
|
return retval;
|
|
|
|
retval = submitWU();
|
|
if (retval)
|
|
return retval;
|
|
|
|
if (testlevel != TEST_LOW_LVL) countWUs();
|
|
|
|
while(!finished)
|
|
{
|
|
printf("Starting DC_processEvents with parameter: 100\n");
|
|
retval = DC_processMasterEvents(100);
|
|
if (retval)
|
|
{
|
|
printf("Error: No event processed in 100 sec. retval = %d\n", retval);
|
|
}
|
|
}
|
|
printf("Exit application\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int init(int argc, char *argv[])
|
|
{
|
|
int retval, i;
|
|
/*
|
|
if (argc != 2)
|
|
{
|
|
printf("Test application need testing lvl argumentum:\n\n");
|
|
printf(" -testlvl=low\n");
|
|
printf(" Create only 1 WU, submit it, and wait for result\n");
|
|
printf(" Using only the minimum DC-API functions\n");
|
|
printf(" -testlvl=high\n");
|
|
printf(" Create more WUs, submit them, ... etc\n");
|
|
printf(" Use all available DC-API functions\n");
|
|
printf(" -testlvl=errors\n");
|
|
printf(" Create WUs for testing the abnormal working\n");
|
|
printf(" -testlvl=stress\n");
|
|
printf(" Under construction....\n");
|
|
return 1;
|
|
}
|
|
*/
|
|
if (argc == 1)
|
|
{
|
|
testlevel = TEST_LOW_LVL;
|
|
}
|
|
|
|
for (i = 1; i < argc; i++)
|
|
{
|
|
if (!strcmp(argv[i], "-testlvl=low"))
|
|
{
|
|
testlevel = TEST_LOW_LVL;
|
|
}
|
|
else if (!strcmp(argv[i], "-testlvl=high"))
|
|
{
|
|
testlevel = TEST_HIGH_LVL;
|
|
}
|
|
else if (!strcmp(argv[i], "-testlvl=errors"))
|
|
{
|
|
testlevel = TEST_ERRORS;
|
|
}
|
|
else if (!strcmp(argv[i], "-testlvl=stress"))
|
|
{
|
|
testlevel = TEST_STRESS;
|
|
}
|
|
else
|
|
{
|
|
printf("Undefined argument '%s'\n", argv[i]);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
printf("Initialise DC\n");
|
|
retval = DC_initMaster("t.conf");
|
|
if (retval != DC_OK)
|
|
{
|
|
printf("DC_init returned with error. Exit application.\n");
|
|
return -1;
|
|
}
|
|
printf("DC_init returned with OK.\n");
|
|
|
|
printf("Set callback functions\n");
|
|
DC_setMasterCb(callbackResult, callbackSubresult, callbackMessage);
|
|
|
|
printf("Get Grid capabilities:\n");
|
|
gc = DC_getGridCapabilities();
|
|
|
|
if (gc & DC_GC_EXITCODE)
|
|
{
|
|
printf("exitcode ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("exitcode ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_STDOUT)
|
|
{
|
|
printf("stdout ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("stdout ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_STDERR)
|
|
{
|
|
printf("stderr ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("stderr ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_LOG)
|
|
{
|
|
printf("Log ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Log ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_SUSPEND)
|
|
{
|
|
printf("Suspend ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Suspend ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_SUBRESULT)
|
|
{
|
|
printf("Subresult ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Subresult ... not ok\n");
|
|
}
|
|
if (gc & DC_GC_MESSAGING)
|
|
{
|
|
printf("Messaging ... ok\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Messaging ... not ok\n");
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void callbackResult(DC_Workunit *wu_result, DC_Result *result)
|
|
{
|
|
char *outfile;
|
|
FILE *f;
|
|
char buf[512];
|
|
|
|
if (testlevel != TEST_LOW_LVL)
|
|
{
|
|
int status = DC_getResultExit(result);
|
|
printf("The exit status of the WU is: %d\n", status);
|
|
}
|
|
|
|
outfile = DC_getResultOutput(result, "out.txt");
|
|
if (!outfile)
|
|
{
|
|
printf("DC_getResultOutput returned with NULL for out.txt\nExit application...\n");
|
|
exit(1);
|
|
}
|
|
|
|
f = fopen(outfile, "r");
|
|
if (!f)
|
|
{
|
|
printf("Cannot open output file: %s\nExit application...\n", outfile);
|
|
exit(1);
|
|
}
|
|
|
|
int i = 0;
|
|
while (fgets(buf, sizeof(buf), f))
|
|
{
|
|
printf("%d. line of out.txt: %s", ++i, buf);
|
|
switch(i)
|
|
{
|
|
case 1: if (!strcmp(buf, "THIS IS A TEST INPUT FILE FOR THE UPPERCASE-DEMO APPLICATION!"))
|
|
{
|
|
printf("Error. The output file is not correct at line %d\n", i);
|
|
}
|
|
break;
|
|
case 2: if (!strcmp(buf, "MESSAGE = HELLO MASTER APPLICATION"))
|
|
{
|
|
printf("Error. The output file is not correct at line %d\n", i);
|
|
}
|
|
break;
|
|
default: printf("The %d line of out.txt is %s\n", i, buf);
|
|
}
|
|
}
|
|
fclose(f);
|
|
|
|
if (testlevel != TEST_LOW_LVL)
|
|
{
|
|
outfile = DC_getResultOutput(result, DC_LABEL_STDOUT);
|
|
if (!outfile)
|
|
{
|
|
printf("callbackResult: DC_getResultOutput returned with NULL for stdout. Exit application.\n");
|
|
exit(1);
|
|
}
|
|
|
|
f = fopen(outfile, "r");
|
|
if (!f)
|
|
{
|
|
printf("callbackResult: Cannot open output file: %s\n", outfile);
|
|
exit(1);
|
|
}
|
|
|
|
fgets(buf, sizeof(buf), f);
|
|
fclose(f);
|
|
printf("callbackResult: 1. line of stdout: %s", buf);
|
|
//printf("callbackResult: destroying WU\n");
|
|
//wu = DC_getResultWU(result);
|
|
}
|
|
|
|
finished = 1;
|
|
DC_destroyWU(wu_result);
|
|
return;
|
|
}
|
|
|
|
static void callbackSubresult(DC_Workunit *wu, const char *label,
|
|
const char *path)
|
|
{
|
|
// not impl yet
|
|
|
|
return;
|
|
}
|
|
|
|
static void callbackMessage(DC_Workunit *wu, const char *message)
|
|
{
|
|
char *tag;
|
|
char *id;
|
|
|
|
id = DC_getWUId(wu);
|
|
tag = DC_getWUTag(wu);
|
|
|
|
printf("callbackMessage: WU with id: %s and tag: %s sent message: %s\n", id, tag, message);
|
|
|
|
return;
|
|
}
|
|
|
|
static int createWU(void)
|
|
{
|
|
int i, retval, wu_num = 0;
|
|
const char *arg[1];
|
|
|
|
if (testlevel == TEST_LOW_LVL)
|
|
{
|
|
wu_num = 1;
|
|
arg[0] = strdup("low_lvl");
|
|
}
|
|
else arg[0] = NULL;
|
|
|
|
for (i = 0; i < wu_num; i++)
|
|
{
|
|
printf("Creating upper_case workunit\n");
|
|
wu[i] = DC_createWU("ts", NULL, 5, "testing");
|
|
if (!wu[i])
|
|
{
|
|
printf("DC_createWU returned with NULL\n");
|
|
return -1;
|
|
}
|
|
if (testlevel == TEST_LOW_LVL) printf("Workunit created\n");
|
|
else printf("Workunit created with id: %s\n", DC_getWUId(wu[i]));
|
|
|
|
printf("Add persistent input file to the workunit test_input.txt -> in.txt \n");
|
|
retval = DC_addWUInput(wu[i], "in.txt", "test_input.txt", DC_FILE_PERSISTENT);
|
|
if (retval)
|
|
{
|
|
printf("DC_addWUInput returned with error\n");
|
|
return -1;
|
|
}
|
|
printf("DC_addWUInput returned with OK\n");
|
|
|
|
printf("Add output file out.txt to the workunit\n");
|
|
retval = DC_addWUOutput(wu[i], "out.txt");
|
|
if (retval)
|
|
{
|
|
printf("DC_addWUOutput returned with error\n");
|
|
return -1;
|
|
}
|
|
printf("DC_addWUOutput returned with OK\n");
|
|
|
|
if (testlevel != TEST_LOW_LVL)
|
|
{
|
|
printf("Set workunit priority to 100\n");
|
|
retval = DC_setWUPriority(wu[i], 100);
|
|
if (retval)
|
|
{
|
|
printf("DC_setWUPriority returned with error\n");
|
|
return -1;
|
|
}
|
|
printf("DC_setWUPriority returned with OK\n");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int submitWU(void)
|
|
{
|
|
int i, retval, wu_num = 0;
|
|
|
|
if (testlevel == TEST_LOW_LVL)
|
|
{
|
|
wu_num = 1;
|
|
}
|
|
|
|
for (i = 0; i < wu_num; i++)
|
|
{
|
|
printf("Submitting workunit\n");
|
|
retval = DC_submitWU(wu[i]);
|
|
if (retval)
|
|
{
|
|
printf("DC_submitWU returned with error. Exit application.\n");
|
|
return -2;
|
|
}
|
|
printf("DC_submitWU returned with OK\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void countWUs(void)
|
|
{
|
|
int i;
|
|
|
|
printf("----------------------------\n");
|
|
printf("countWUs:\n");
|
|
|
|
i = DC_getWUNumber(DC_WU_READY);
|
|
printf(" READY: %d\n",i);
|
|
|
|
i = DC_getWUNumber(DC_WU_RUNNING);
|
|
printf(" RUNNING: %d\n",i);
|
|
|
|
i = DC_getWUNumber(DC_WU_FINISHED);
|
|
printf(" FINISHED: %d\n",i);
|
|
|
|
i = DC_getWUNumber(DC_WU_SUSPENDED);
|
|
printf(" SUSPENDED: %d\n",i);
|
|
|
|
i = DC_getWUNumber(DC_WU_ABORTED);
|
|
printf(" ABORTED: %d\n",i);
|
|
|
|
i = DC_getWUNumber(DC_WU_UNKNOWN);
|
|
printf(" UNKNOWN: %d\n",i);
|
|
|
|
printf("----------------------------\n");
|
|
}
|
|
|