void recover(DfaSet * dfaSet) {
StateMachine * sm;
StateMachine * this;
byte * bsm;
byte * bsm_id; // Need these to make gcc -O2 happy (avoiding type-punning...)
int keySize = sizeof(state_machine_id);
state_machine_id * sm_id;
int valueSize = sizeof(StateMachine);
lladd_hash_iterator * it = ThashIterator(dfaSet->smash->xid,
dfaSet->smash->hash,
keySize, valueSize);
while(ThashNext(dfaSet->smash->xid, it, &bsm_id, &keySize, &bsm, &valueSize)) {
sm = (StateMachine*)bsm;
sm_id = (state_machine_id*)bsm_id;
assert(*sm_id == sm->machine_id);
this = getSmash(dfaSet->smash, *sm_id);
DEBUG("StateMachine %ld\n", sm->machine_id);
this->worker_thread = spawn_worker_thread(dfaSet, sm->machine_id);
free(sm_id);
free(sm);
}
}
void* main_loop(DfaSet *dfaSet) {
Message * message = malloc(sizeof(Message));
char * from = malloc(sizeof(char) * MAX_ADDRESS_LENGTH);
NetworkSetup * networkSetup = malloc(sizeof(NetworkSetup));
int recieved_message = 0;
StateMachine * stateMachine;
writelock(dfaSet->lock, 300);
memcpy(networkSetup, &(dfaSet->networkSetup), sizeof(NetworkSetup));
writeunlock(dfaSet->lock);
/** @todo the locking scheme for this loop could be improved. The loop assumes that
pointers to existing state machines could be invalidated by unrelated threads,
and this forces it to hold a global write lock during processing. */
while(1) {
int i;
state_name new_state, current_state;
int new_machine = 0;
/*Listen on socket... */
if(recieved_message) {
writeunlock(dfaSet->lock);
recieved_message = 0;
}
if(receive_message(networkSetup, message, from) <= 0) {
continue;
}
recieved_message = 1;
writelock(dfaSet->lock, 200);
stateMachine = getSmash(dfaSet->smash, message->to_machine_id);
DEBUG("Lookup %ld, ret = %d\n", message->to_machine_id, ret);
/** @todo Check states to make sure they actually exist? */
if(stateMachine == NULL) {
DEBUG("Allocate machine %ld->", message->to_machine_id); fflush(NULL);
if(message->to_machine_id == NULL_MACHINE) {
stateMachine = allocSmash(dfaSet->smash);
} else {
/* @todo: Check id. */
stateMachine = insertSmash(dfaSet->smash, message->to_machine_id);
}
if(stateMachine == NULL) {
fprintf(stderr, "Too many state machines. Dropping request for new one.\n");
continue;
}
new_machine = 1;
stateMachine->worker_thread = (pid_t)0;
stateMachine->page = NULL;
/* @todo libdfa doesn't use the 'conventional' null recordid, {0,0,-1} */
stateMachine->page_id.page = 0;
stateMachine->page_id.slot = 0;
stateMachine->page_id.size = 0;
current_state = NULL_STATE;
} else {
current_state = stateMachine->current_state;
}
new_state = current_state;
/* Find the appropriate transition */
assert(message->to_machine_id == stateMachine->machine_id || message->to_machine_id == NULL_MACHINE);
for(i = 0; i< dfaSet->transition_count; i++) {
if(dfaSet->transitions[i].remote_state == message->type &&
dfaSet->transitions[i].pre_state == current_state) {
break;
}
}
if(i == dfaSet->transition_count) {
fprintf(stderr, "%ld received: %ld-%d:%d->? (bad message from %s)\n", stateMachine->machine_id, message->from_machine_id,
message->type, current_state, from);
continue;
}
if(dfaSet->transitions[i].fcn_ptr == NULL) {
new_state = dfaSet->transitions[i].post_state;
} else {
/* Evaluate callback -- This produces a new state, and
overwrites m with a new message for the state machine. */
int ret = (dfaSet->transitions[i].fcn_ptr)(dfaSet, stateMachine, message, from);
if (dfaSet->transitions[i].post_state == OVERRIDDEN_STATE) {
if( ret != OVERRIDDEN_STATE) {
new_state = ret;
} /* else leave new_state alone; the transition failed. */
} else if (ret) {
new_state = dfaSet->transitions[i].post_state;
}
}
/* Update machine state. */
if(new_state == NULL_STATE) {
/* Time to de-allocate machine */
if(stateMachine->worker_thread == (pid_t)0) {
/* No worker thread, so just deallocate, and move on */
freeSmash(dfaSet->smash, stateMachine->machine_id);
continue;
} else {
/* NULL_STATE_TOMBSTONE tells the worker thread that it's
time to shut down. (NULL_STATE is reserved by monoTree
for machines that have already been deleted..) */
new_state = NULL_STATE_TOMBSTONE;
}
assert(!new_machine);
}
if(new_state != current_state) {
DEBUG("%ld transitioned on: %ld-%d:%d->%d from %s\n", stateMachine->machine_id, message->from_machine_id,
dfaSet->transitions[i].remote_state, dfaSet->transitions[i].pre_state, dfaSet->transitions[i].post_state, from);
DEBUG(" -> %d %ld\n", new_state, message->from_machine_id);
assert(new_state != NULL_STATE);
stateMachine->current_state = new_state;
stateMachine->last_transition = time(NULL);
/* @todo Is this general enough? The transition function is
able to overwrite both variables, so it should be
good enough. */
memcpy(&(stateMachine->message_recipient), from, MAX_ADDRESS_LENGTH);
memcpy(&(stateMachine->message), message, sizeof(Message));
/* We don't want to just swap the sender and recipient,
since we might have just allocated this machine. If not,
then the original message's recipient should be the
same as stateMachine->machine_id anyway.
At any rate, the transition function should overwrite
message->from_machine_id to change the machine that the
state machine will deal with.
*/
stateMachine->message.from_machine_id = stateMachine->machine_id;
stateMachine->message.to_machine_id = message->from_machine_id;
if(dfaSet->transitions[i].force) {
setSmash(dfaSet->smash, stateMachine->machine_id);
forceSmash(dfaSet->smash);
}
/* Fork or signal the process if there already is one. */
if(stateMachine->worker_thread == (pthread_t)NULL) {
assert ((stateMachine->current_state != NULL_STATE) &&
(stateMachine->current_state != NULL_STATE_TOMBSTONE));
stateMachine->worker_thread = spawn_worker_thread(dfaSet, stateMachine->machine_id);
} else {
// This was a broadcast, but was recently changed to signal for
// performance reasons.
pthread_cond_signal(stateMachine->sleepCond);
}
}
}
}
int start_server(socket_t sockfd)
{
struct sockaddr_storage client_addr;
socklen_t sin_size;
_TCHAR ipstr[INET6_ADDRSTRLEN];
socket_t client_sockfd;
dyarr_t workers = dyarr_new(sizeof(worker_context_t), false, true);
size_t i;
int error_code = EXIT_SUCCESS;
assert(sockfd != INVALID_SOCKET);
if (workers == NULL)
{
fprintf(stderr, "No enough memory!\n");
return EXIT_FAILURE;
}
while (true)
{
sin_size = sizeof client_addr;
client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &sin_size);
if (client_sockfd == INVALID_SOCKET)
{
print_error_ex(_T("accept"));
continue;
}
if (inet_ntop(client_addr.ss_family,
get_in_addr((struct sockaddr *)&client_addr),
ipstr, sizeof(ipstr) / sizeof(ipstr[0])) != NULL)
{
_ftprintf(stdout, _T("Got connection from: %s.\n"), ipstr);
if (!spawn_worker_thread(ipstr, client_sockfd, workers))
{
error_code = EXIT_FAILURE;
break;
}
}
else
{
fprintf(stderr, "inet_ntop failed.\n");
}
}
for (i = 0; i < dyarr_size(workers); ++i)
{
worker_context_t *ctx = dyarr_at(workers, i);
if (ctx->handle != NULL)
{
InterlockedExchange(&(ctx->running), 0);
printf("Waiting for worker thread exiting...\n");
WaitForSingleObject(ctx->handle, INFINITE);
CloseHandle(ctx->handle);
ctx->handle = NULL;
}
if (ctx->sockfd != INVALID_SOCKET)
{
closesock(ctx->sockfd);
ctx->sockfd = INVALID_SOCKET;
}
}
dyarr_free(&workers);
return error_code;
}