char * test_update()
{
Snippet * oldSnippet = DB_get(1);
Snippet * newSnippet = DB_get(1);
bcatcstr(newSnippet->code,"i've updated the code !");
DB_update(newSnippet);
snippet_destroy(newSnippet);
newSnippet = NULL;
newSnippet = DB_get(1);
mu_assert(biseq(oldSnippet->code, newSnippet->code) == 0, "The code should be different.");
snippet_destroy(newSnippet);
snippet_destroy(oldSnippet);
return NULL;
}
// *************************
// main function
// *************************
int main(int argc, char **argv)
{
struct MessageFromCoach
{
char Head;
char MatchMode; /** 比赛模式，如果*/
char MatchType;
}coach2robot;
int lifetime;
int value = 0;
if(signal(SIGINT, signal_catch) == SIG_ERR)
{
printf("Error registering signal handler");
return -1;
}
if(DB_init() != 0)
return -1;
while(end == 0)
{
printf("\n\n\n");
lifetime = DB_get(Agent0,MESSAGEFROMCOACHINFO, &coach2robot);
printf("%d",coach2robot.MatchMode);
sleep(0.5);
}
DB_free();
return 0;
}
int DB_valid_schema(tns_value_t *res, int row, int ncols, ...)
{
va_list argp;
va_start(argp, ncols);
int i = 0;
check(tns_get_type(res) == tns_tag_list, "Invalid result set, must be a list.");
int rows = darray_end(res->value.list);
check(rows != -1, "Result isn't in a table format.");
check(row < rows, "Row is past end of result set: %d > %d", row, rows);
// get the row they ask for
tns_value_t *row_data = darray_get(res->value.list, row);
// make sure it's got the right number of columns
check(tns_get_type(row_data) == tns_tag_list, "Invalid row %d, must be a list.", row);
int cols = darray_end(row_data->value.list);
check(cols == ncols, "Expected %d columns, but result set has %d.", cols, ncols);
for(i = 0; i < ncols; i++) {
tns_type_tag expecting = va_arg(argp, tns_type_tag);
tns_value_t *cell = DB_get(res, row, i);
check(tns_get_type(cell) == expecting,
"Row %d, Column %d has wrong type.", row, i);
}
va_end(argp);
return 1;
error:
va_end(argp);
return 0;
}
char * test_get()
{
Snippet * snippet = DB_get(1);
mu_assert(snippet != NULL,"Failed to select from db.");
log_info("Printing Snippet from test_get");
snippet_print(snippet,stdout);
snippet_destroy(snippet);
snippet = DB_get(3);
mu_assert(snippet != NULL,"Failed to select from db.");
log_info("Printing Snippet from test_get");
snippet_print(snippet,stdout);
snippet_destroy(snippet);
snippet = DB_get(100);
mu_assert(snippet == NULL, "Should failed here.");
if(snippet)
snippet_destroy(snippet);
return NULL;
}
char * test_delete()
{
DArray * array = DB_get_name("select db");
Snippet * snippet = NULL;
snippet = DArray_pop(array);
mu_assert(snippet != NULL, "DB empty.");
int old_id = snippet->id;
int rc = DB_delete(snippet);
snippet_destroy(snippet);
DArray_clear_destroy(array,snippet_destroy);
mu_assert(rc == 0, "Failed to delete.");
log_info("snippet * = %p",snippet);
snippet = NULL;
snippet = DB_get(old_id);
mu_assert(snippet == NULL, "This snippet Shouldn't exist.");
log_info("about to quite test_delete");
if(snippet != NULL)
snippet_destroy(snippet);
return NULL;
}
//*************************
// Main
//
int main(int argc, char *argv[])
{
int sckt;
pthread_t recvThread;
char sendBuffer[BUFFER_SIZE];
int indexBuffer;
int sharedRecs;
RTDBconf_var rec[MAX_RECS];
unsigned int frameCounter = 0;
int i, j;
int life;
struct sched_param proc_sched;
pthread_attr_t thread_attr;
struct itimerval it;
struct _frameHeader frameHeader;
struct timeval tempTimeStamp;
nosend = 0;
if ((argc < 2) || (argc > 3))
{
printUsage();
return (-1);
}
if (argc == 3)
{
if(strcmp(argv[2], "nosend") == 0)
{
printf("\n*** Running in listing only mode ***\n\n");
nosend = 1;
}
else
{
printUsage();
return (-1);
}
}
/* initializations */
delay = 0;
timer = 0;
end = 0;
RUNNING_AGENTS = 1;
/* Assign a real-time priority to process */
proc_sched.sched_priority=60;
if ((sched_setscheduler(getpid(), SCHED_FIFO, &proc_sched)) < 0)
{
PERRNO("setscheduler");
return -1;
}
if(signal(SIGALRM, signal_catch) == SIG_ERR)
{
PERRNO("signal");
return -1;
}
if(signal(SIGINT, signal_catch) == SIG_ERR)
{
PERRNO("signal");
return -1;
}
if((sckt = openSocket(argv[1])) == -1)
{
PERR("openMulticastSocket");
printf("\nUsage: comm <interface_name>\n\n");
return -1;
}
if(DB_init() == -1)
{
PERR("DB_init");
closeSocket(sckt);
return -1;
}
if((sharedRecs = DB_comm_ini(rec)) < 1)
{
PERR("DB_comm_ini");
DB_free();
closeSocket(sckt);
return -1;
}
#ifdef FILEDEBUG
if ((filedebug = fopen("log.txt", "w")) == NULL)
{
PERRNO("fopen");
DB_free();
closeSocket(sckt);
return -1;
}
#endif
/* initializations */
for (i=0; i<MAX_AGENTS; i++)
{
lostPackets[i]=0;
agent[i].lastFrameCounter = 0;
agent[i].state = NOT_RUNNING;
agent[i].removeCounter = 0;
}
myNumber = Whoami();
agent[myNumber].state = RUNNING;
/* receive thread */
pthread_attr_init (&thread_attr);
pthread_attr_setinheritsched (&thread_attr, PTHREAD_INHERIT_SCHED);
if ((pthread_create(&recvThread, &thread_attr, receiveDataThread, (void *)&sckt)) != 0)
{
PERRNO("pthread_create");
DB_free();
closeSocket(sckt);
return -1;
}
/* Set itimer to reactivate the program */
it.it_value.tv_usec=(__suseconds_t)(TTUP_US);
it.it_value.tv_sec=0;
it.it_interval.tv_usec=(__suseconds_t)(TTUP_US);
it.it_interval.tv_sec=0;
setitimer (ITIMER_REAL, &it, NULL);
printf("communication: STARTED in ");
#ifdef UNSYNC
printf("unsync mode...\n");
#else
printf("sync mode...\n");
#endif
MTRand randomGenerator;
while (!end)
{
//pause();
double waitTime = randomGenerator.randNorm(0,1) * TTUP_US * 0.05 + TTUP_US;
usleep(waitTime);
// not timer event
if (timer == 0)
continue;
#ifndef UNSYNC
// dynamic agent 0
if ((delay > (int)MIN_UPDATE_DELAY_US) && (agent[myNumber].dynamicID == 0) && timer == 1)
{
it.it_value.tv_usec = (__suseconds_t)(delay - (int)MIN_UPDATE_DELAY_US/2);
it.it_value.tv_sec = 0;
setitimer (ITIMER_REAL, &it, NULL);
delay = 0;
continue;
}
#endif
timer = 0;
indexBuffer = 0;
bzero(sendBuffer, BUFFER_SIZE);
update_stateTable();
// update dynamicID
j = 0;
for (i = 0; i < MAX_AGENTS; i++)
{
if ((agent[i].state == RUNNING) || (agent[i].state == REMOVE))
{
agent[i].dynamicID = j;
j++;
}
agent[myNumber].stateTable[i] = agent[i].state;
}
RUNNING_AGENTS = j;
MAX_DELTA = (int)(TTUP_US/RUNNING_AGENTS * 2/3);
// frame header
frameHeader.number = myNumber;
frameHeader.counter = frameCounter;
frameCounter ++;
for (i = 0; i < MAX_AGENTS; i++)
frameHeader.stateTable[i] = agent[myNumber].stateTable[i];
frameHeader.noRecs = sharedRecs;
memcpy(sendBuffer + indexBuffer, &frameHeader, sizeof(frameHeader));
indexBuffer += sizeof(frameHeader);
for(i = 0; i < sharedRecs; i++)
{
// id
memcpy(sendBuffer + indexBuffer, &rec[i].id, sizeof(rec[i].id));
indexBuffer += sizeof(rec[i].id);
// size
memcpy(sendBuffer + indexBuffer, &rec[i].size, sizeof(rec[i].size));
indexBuffer += sizeof(rec[i].size);
// life and data
life = DB_get(myNumber, rec[i].id, sendBuffer + indexBuffer + sizeof(life));
memcpy(sendBuffer + indexBuffer, &life, sizeof(life));
indexBuffer = indexBuffer + sizeof(life) + rec[i].size;
}
if (indexBuffer > BUFFER_SIZE)
{
PERR("Pretended frame is bigger that the available buffer.");
PERR("Please increase the buffer size or reduce the number of disseminated records");
break;
}
if (nosend == 0)
{
if (sendData(sckt, sendBuffer, indexBuffer) != indexBuffer)
PERRNO("Error sending data");
}
gettimeofday (&tempTimeStamp, NULL);
lastSendTimeStamp.tv_sec = tempTimeStamp.tv_sec;
lastSendTimeStamp.tv_usec = tempTimeStamp.tv_usec;
// reset values for next round
for (i=0; i<MAX_AGENTS; i++)
{
agent[i].delta = 0;
agent[i].received = NO;
}
}
FDEBUG (filedebug, "\nLost Packets:\n");
for (i=0; i<MAX_AGENTS; i++)
FDEBUG (filedebug, "%d\t", lostPackets[i]);
FDEBUG (filedebug, "\n");
printf("communication: STOPED.\nCleaning process...\n");
#ifdef FILEDEBUG
fclose (filedebug);
#endif
closeSocket(sckt);
pthread_join(recvThread, NULL);
DB_free();
printf("communication: FINISHED.\n");
return 0;
}