static ssize_t try_handler(machine_t *machine, request_t *request){ // {{{
ssize_t ret;
data_t freeme;
request_t *try_request;
try_userdata *userdata = (try_userdata *)machine->userdata;
try_threaddata *threaddata = thread_data_get(&userdata->thread_data);
threaddata->machine = machine;
threaddata->request = request;
threaddata->ret = 0;
data_set_void(&freeme);
if(userdata->request == 0){
try_request = request;
}else{
if( (ret = get_hash(hash_data_find(request, userdata->request), &freeme, &try_request)) < 0)
return ret;
}
request_t r_next[] = {
{ userdata->return_to, DATA_MACHINET(userdata->try_end) },
hash_inline(try_request),
hash_end
};
fastcall_query r_query = { { 3, ACTION_QUERY }, r_next };
if( (ret = data_query(&userdata->machine, &r_query)) < 0){
if(userdata->request == 0){
request_t r_pass[] = {
{ HK(ret), DATA_PTR_SIZET(&ret) },
hash_inline(request),
hash_end
};
threaddata->ret = machine_pass(machine, r_pass);
}else{
request_t r_pass[] = {
{ HK(ret), DATA_PTR_SIZET(&ret) },
hash_inline(try_request),
hash_end
};
request_t r_next[] = {
{ HK(ret), DATA_PTR_SIZET(&ret) },
{ userdata->request_out, DATA_PTR_HASHT(r_pass) },
hash_inline(request),
hash_end
};
threaddata->ret = machine_pass(machine, r_next);
}
}
data_free(&freeme);
return threaddata->ret;
} // }}}
static ssize_t try_end_handler(machine_t *machine, request_t *request){ // {{{
try_userdata *userdata = (try_userdata *)machine->userdata;
try_threaddata *threaddata = thread_data_get(&userdata->thread_data);
if(userdata->request == 0){
threaddata->ret = machine_pass(threaddata->machine, request);
}else{
request_t r_next[] = {
{ userdata->request_out, DATA_PTR_HASHT(request) },
hash_inline(threaddata->request),
hash_end
};
threaddata->ret = machine_pass(threaddata->machine, r_next);
}
return 0;
} // }}}
static ssize_t morph_handler(machine_t *machine, request_t *request){ // {{{
ssize_t ret;
hash_t *pipelines;
morph_userdata *userdata = (morph_userdata *)machine->userdata;
if(userdata->running == 0){
config_t child_config[] = {
{ 0, DATA_HASHT(
hash_inline(request),
hash_inline(userdata->machine_config),
hash_end
)},
hash_end
};
if( (ret = pipelines_new(&pipelines, child_config)) < 0)
return ret;
userdata->running = 1;
userdata->machine = pipelines[0].data.ptr;
data_set_void(&pipelines[0].data);
hash_free(pipelines);
if(userdata->pass_first == 0)
return 0;
}
return machine_pass(userdata->machine, request);
} // }}}
static ssize_t implode_request(machine_t *machine, request_t *request){ // {{{
implode_userdata *userdata = (implode_userdata *)machine->userdata;
request_t r_next[] = {
{ userdata->buffer, DATA_PTR_HASHT(request) },
hash_inline(request),
hash_end
};
return machine_pass(machine, r_next);
} // }}}
static ssize_t murmur2_64_handler(machine_t *machine, request_t *request){ // {{{
uint64_t hash = 0;
data_t *key = NULL;
murmur_userdata *userdata = (murmur_userdata *)machine->userdata;
key = hash_data_find(request, userdata->input);
if(key == NULL){
if(userdata->fatal == 0)
return machine_pass(machine, request);
return error("input key not supplied");
}
hash = MurmurHash64A(key, 0);
request_t r_next[] = {
{ userdata->output, DATA_UINT64T(hash) },
hash_next(request)
};
return machine_pass(machine, r_next);
} // }}}
static ssize_t mutex_request(machine_t *machine, request_t *request){ // {{{
ssize_t ret;
mutex_userdata *userdata = (mutex_userdata *)machine->userdata;
pthread_mutex_lock(&userdata->mutex);
ret = machine_pass(machine, request);
pthread_mutex_unlock(&userdata->mutex);
return ret;
} // }}}
static ssize_t struct_machine_pack(machine_t *machine, request_t *request){
ssize_t ret;
size_t struct_size;
data_t *buffer;
request_t *values;
struct_userdata *userdata = (struct_userdata *)machine->userdata;
switch(userdata->values){
case STRUCT_VALUES_WHOLE: values = request; break;
case STRUCT_VALUES_ONE:
hash_data_get(ret, TYPE_HASHT, values, request, userdata->key_values);
if(ret != 0)
return error("hash with keys not supplied");
break;
};
if(userdata->lazy == 1){
request_t r_next[] = {
{ userdata->buffer, DATA_STRUCTT(userdata->structure, values) },
hash_next(request)
};
return machine_pass(machine, r_next);
}else{
buffer = hash_data_find(request, userdata->buffer);
if(buffer != NULL){
if( (struct_size = struct_pack(userdata->structure, values, buffer)) == 0)
return error("struct_pack failed");
request_t new_request[] = {
{ userdata->size, DATA_SIZET(struct_size) },
hash_next(request)
};
return machine_pass(machine, new_request);
}
return machine_pass(machine, request);
}
}
static ssize_t debug_request(machine_t *machine, request_t *request){ // {{{
ssize_t ret;
debug_userdata *userdata = (debug_userdata *)machine->userdata;
if( (userdata->flags & DEBUG_BEFORE) != 0)
debug_do(machine, request, DEBUG_BEFORE);
ret = machine_pass(machine, request);
if( (userdata->flags & DEBUG_AFTER) != 0)
debug_do(machine, request, DEBUG_AFTER);
return ret;
} // }}}
uintmax_t limit_parameter_get(machine_t *machine, limit_userdata *userdata){ // {{{
switch(userdata->parameter){
case PARAMETER_ONE: return (machine->machine_type_hash.func_handler == &limit_machine_request_died) ? 0 : 1;
case PARAMETER_TICKS: return userdata->usage_ticks_last;
case PARAMETER_REQUEST:;
uintmax_t buffer = 0;
request_t r_query[] = {
{ HK(buffer), DATA_PTR_UINTT(&buffer) },
hash_next(userdata->parameter_request)
};
machine_pass(machine, r_query);
return buffer;
default:
break;
};
return 0;
} // }}}
static ssize_t struct_machine_unpack(machine_t *machine, request_t *request){
ssize_t ret;
data_t *buffer;
request_t *values;
struct_userdata *userdata = (struct_userdata *)machine->userdata;
buffer = hash_data_find(request, userdata->buffer);
if(buffer != NULL){
switch(userdata->values){
case STRUCT_VALUES_WHOLE: values = request; break;
case STRUCT_VALUES_ONE:
hash_data_get(ret, TYPE_HASHT, values, request, userdata->key_values);
if(ret != 0)
return error("hash with keys not supplied");
break;
};
if(struct_unpack(userdata->structure, values, buffer) == 0)
return error("struct_unpack failed");
}
return machine_pass(machine, request);
}
void * ipc_shmem_listen (void *ipc){ // {{{
ipc_shmem_block *block;
ipc_shmem_userdata *userdata = (ipc_shmem_userdata *)((ipc_t *)ipc)->userdata;
while(1){
if( (block = shmem_get_block(userdata, STATUS_WRITTEN, STATUS_EXECUTING)) == NULL)
break;
// run request
request_t req[] = {
{ userdata->buffer, DATA_RAW( userdata->shmdata + block->data_rel_ptr, userdata->shmaddr->item_size ) },
hash_end
};
machine_pass(((ipc_t *)ipc)->machine, req);
// update status. if client don't want read results - free block, overwise notify client
if(shmem_block_status(userdata, block, STATUS_EXECUTING,
((block->return_result == 0) ? STATUS_FREE : STATUS_EXEC_DONE)
) < 0)
break;
}
//error("ipc_shmem_listen dead\n");
return NULL;
} // }}}
void limit_machine_action(machine_t *machine, rule *rule){ // {{{
limit_userdata *userdata = (limit_userdata *)machine->userdata;
switch(rule->action){
case ACTION_DESTROY:;
// set machine mode to died
limit_set_handler(machine, &limit_machine_request_died);
if(userdata->perfork_childs != &userdata->perfork_childs_own){
// kill childs for forked shops, keep for initial
pipeline_destroy(machine->cnext);
}
break;
case ACTION_REQUEST:;
machine_pass(machine, rule->action_request);
break;
default:
break;
};
// update parameter
userdata->usage_parameter = limit_parameter_get(machine, userdata);
} // }}}
static ssize_t null_handler(machine_t *machine, request_t *request){ // {{{
return machine_pass(machine, request);
} // }}}
