/**
* Run the event loop until we've got a response for all of our spooled
* commands. You should not call this function from within your callbacks.
*
* @param instance the instance to run the event loop for.
*
* @author Trond Norbye
*/
LIBCOUCHBASE_API
lcb_error_t lcb_wait(lcb_t instance)
{
if (instance->wait != 0) {
return instance->last_error;
}
if (instance->connection.state != LCB_CONNSTATE_CONNECTED
&& !lcb_flushing_buffers(instance)
&& (instance->compat.type == LCB_CACHED_CONFIG
|| instance->compat.type == LCB_MEMCACHED_CLUSTER)
&& instance->vbucket_config != NULL) {
return LCB_SUCCESS;
}
/*
* The API is designed for you to run your own event loop,
* but should also work if you don't do that.. In order to be
* able to know when to break out of the event loop, we're setting
* the wait flag to 1
*/
instance->last_error = LCB_SUCCESS;
instance->wait = 1;
if (instance->connection.state != LCB_CONNSTATE_CONNECTED
|| lcb_flushing_buffers(instance)
|| hashset_num_items(instance->timers) > 0
|| hashset_num_items(instance->durability_polls) > 0) {
lcb_size_t ii;
for (ii = 0; ii < instance->nservers; ii++) {
lcb_server_t *c = instance->servers + ii;
if (lcb_server_has_pending(c)) {
lcb_connection_delay_timer(&c->connection);
}
}
instance->io->v.v0.run_event_loop(instance->io);
} else {
instance->wait = 0;
}
if (instance->vbucket_config) {
return LCB_SUCCESS;
}
return instance->last_error;
}
void lcb_maybe_breakout(lcb_t instance)
{
/**
* So we're done with normal operations. See if we need a refresh
*/
if (instance->wait) {
if (!lcb_flushing_buffers(instance)
&& hashset_num_items(instance->timers) == 0
&& hashset_num_items(instance->durability_polls) == 0) {
instance->wait = 0;
instance->io->v.v0.stop_event_loop(instance->io);
}
}
}
static void trivial(void)
{
char *missing = "missing";
char *items[] = {"zero", "one", "two", "three", NULL};
char *foo = "foo";
size_t ii, nitems = 4;
hashset_t set = hashset_create();
if (set == NULL) {
fprintf(stderr, "failed to create hashset instance\n");
abort();
}
for (ii = 0; ii < nitems; ++ii) {
hashset_add(set, items[ii]);
}
for (ii = 0; ii < nitems; ++ii) {
assert(hashset_is_member(set, items[ii]));
}
assert(hashset_is_member(set, missing) == 0);
assert(hashset_remove(set, items[1]) == 1);
assert(hashset_num_items(set) == 3);
assert(hashset_remove(set, items[1]) == 0);
assert(hashset_add(set, foo) == 1);
assert(hashset_add(set, foo) == 0);
hashset_destroy(set);
}
void libcouchbase_maybe_breakout(libcouchbase_t instance)
{
if (instance->wait) {
if (!libcouchbase_has_data_in_buffers(instance)
&& hashset_num_items(instance->timers) == 0) {
instance->wait = 0;
instance->io->stop_event_loop(instance->io);
}
}
}
int libcouchbase_has_data_in_buffers(libcouchbase_t instance)
{
libcouchbase_size_t ii;
for (ii = 0; ii < instance->nservers; ++ii) {
libcouchbase_server_t *c = instance->servers + ii;
if (c->cmd_log.nbytes || c->output.nbytes || c->input.nbytes ||
c->pending.nbytes || hashset_num_items(c->http_requests)) {
return 1;
}
}
return 0;
}
int lcb_flushing_buffers(lcb_t instance)
{
lcb_size_t ii;
if (hashset_num_items(instance->http_requests)) {
return 1;
}
for (ii = 0; ii < instance->nservers; ++ii) {
if (lcb_server_has_pending(instance->servers + ii)) {
return 1;
}
}
return 0;
}
int lcb_flushing_buffers(lcb_t instance)
{
lcb_size_t ii;
if (hashset_num_items(instance->http_requests)) {
return 1;
}
for (ii = 0; ii < instance->nservers; ++ii) {
if (lcb_server_has_pending(instance->servers + ii)) {
return 1;
}
}
if (instance->bootstrap.type == LCB_CONFIG_TRANSPORT_CCCP &&
lcb_server_has_pending(&instance->bootstrap.via.cccp.server)) {
return 1;
}
return 0;
}
/**
* Run the event loop until we've got a response for all of our spooled
* commands. You should not call this function from within your callbacks.
*
* @param instance the instance to run the event loop for.
*
* @author Trond Norbye
*/
LIBCOUCHBASE_API
void libcouchbase_wait(libcouchbase_t instance)
{
if (instance->wait != 0) {
return;
}
/*
* The API is designed for you to run your own event loop,
* but should also work if you don't do that.. In order to be
* able to know when to break out of the event loop, we're setting
* the wait flag to 1
*/
instance->wait = 1;
if (instance->vbucket_config == NULL) {
/* Initial configuration. Set a timer */
instance->vbucket_state_listener_last =
instance->vbucket_state_listener;
instance->vbucket_state_listener = breakout_vbucket_state_listener;
/* Initial connection timeout */
instance->io->update_timer(instance->io,
instance->timeout.event,
instance->timeout.usec,
instance,
initial_connect_timeout_handler);
}
if (instance->vbucket_config == NULL || libcouchbase_has_data_in_buffers(instance)
|| hashset_num_items(instance->timers) > 0) {
instance->io->run_event_loop(instance->io);
} else {
instance->wait = 0;
}
/*
* something else will call libcouchbase_maybe_breakout with a corresponding
* stop_event_loop()
*/
}
/**
* Run the event loop until we've got a response for all of our spooled
* commands. You should not call this function from within your callbacks.
*
* @param instance the instance to run the event loop for.
*
* @author Trond Norbye
*/
LIBCOUCHBASE_API
lcb_error_t lcb_wait(lcb_t instance)
{
if (instance->wait != 0) {
return instance->last_error;
}
if (!instance->connected && !lcb_has_data_in_buffers(instance)
&& instance->compat.type == LCB_CACHED_CONFIG
&& instance->vbucket_config != NULL) {
return LCB_SUCCESS;
}
/*
* The API is designed for you to run your own event loop,
* but should also work if you don't do that.. In order to be
* able to know when to break out of the event loop, we're setting
* the wait flag to 1
*/
instance->last_error = LCB_SUCCESS;
instance->wait = 1;
if (!instance->connected || lcb_has_data_in_buffers(instance)
|| hashset_num_items(instance->timers) > 0) {
lcb_size_t idx;
/* update timers on all servers */
for (idx = 0; idx < instance->nservers; ++idx) {
lcb_update_server_timer(instance->servers + idx);
}
instance->io->v.v0.run_event_loop(instance->io);
} else {
instance->wait = 0;
}
return instance->last_error;
}
LIBCOUCHBASE_API
void lcb_destroy(lcb_t instance)
{
lcb_size_t ii;
lcb_settings *settings = &instance->settings;
if (instance->cur_configinfo) {
lcb_clconfig_decref(instance->cur_configinfo);
instance->cur_configinfo = NULL;
}
instance->vbucket_config = NULL;
lcb_bootstrap_destroy(instance);
lcb_confmon_destroy(instance->confmon);
hostlist_destroy(instance->usernodes);
if (instance->timers != NULL) {
for (ii = 0; ii < instance->timers->capacity; ++ii) {
if (instance->timers->items[ii] > 1) {
lcb_timer_destroy(instance,
(lcb_timer_t)instance->timers->items[ii]);
}
}
hashset_destroy(instance->timers);
}
if (instance->durability_polls) {
struct lcb_durability_set_st **dset_list;
lcb_size_t nitems = hashset_num_items(instance->durability_polls);
dset_list = (struct lcb_durability_set_st **)
hashset_get_items(instance->durability_polls, NULL);
if (dset_list) {
for (ii = 0; ii < nitems; ii++) {
lcb_durability_dset_destroy(dset_list[ii]);
}
free(dset_list);
}
hashset_destroy(instance->durability_polls);
}
for (ii = 0; ii < instance->nservers; ++ii) {
lcb_server_destroy(instance->servers + ii);
}
if (instance->http_requests) {
for (ii = 0; ii < instance->http_requests->capacity; ++ii) {
if (instance->http_requests->items[ii] > 1) {
lcb_http_request_t htreq =
(lcb_http_request_t)instance->http_requests->items[ii];
/**
* We don't want to invoke callbacks *or* remove it from our
* hash table
*/
htreq->status |= LCB_HTREQ_S_CBINVOKED | LCB_HTREQ_S_HTREMOVED;
/* we should figure out a better error code for this.. */
lcb_http_request_finish(instance, htreq, LCB_ERROR);
}
}
}
hashset_destroy(instance->http_requests);
free(instance->servers);
connmgr_destroy(instance->memd_sockpool);
if (settings->io && settings->io->v.v0.need_cleanup) {
lcb_destroy_io_ops(settings->io);
}
ringbuffer_destruct(&instance->purged_buf);
ringbuffer_destruct(&instance->purged_cookies);
free(instance->histogram);
free(instance->scratch);
free(settings->username);
free(settings->password);
free(settings->bucket);
free(settings->sasl_mech_force);
if (instance->cmdht) {
genhash_free(instance->cmdht);
instance->cmdht = NULL;
}
memset(instance, 0xff, sizeof(*instance));
free(instance);
}
double genHOMFitness(char* srcDir,char*target,char*makeDir,Config *user_config,char*original_source,MResult *mResult,HOMutant *hom){
char **args_combineFOM = malloc(sizeof(char*)*(hom->FOMutants_count+4));
args_combineFOM[0]="bash";
args_combineFOM[1]="combineFOM.sh";
args_combineFOM[2]=original_source;
args_combineFOM[hom->FOMutants_count+2]=NULL;
//Merge all the FOM source files to generate the HOM
int i;
for (i=0;i<hom->FOMutants_count;i++){
args_combineFOM[i+3]=hom->FOMutants[i].mutant_source_file;
}
startprogram(args_combineFOM,NULL,0);
free(args_combineFOM);
char hom_dir[strlen(srcDir)+strlen("hom_dir.log")+2];
sprintf(hom_dir,"%s/%s", srcDir, "hom_dir.log");
char hom_dir_loc[strlen(srcDir)+20];
char hom_file_name[strlen(srcDir)+20];
FILE* hom_dir_file =fopen(hom_dir,"r");
if(hom_dir_file==NULL){
return -1;
}
fscanf (hom_dir_file, "%s %s",hom_file_name , hom_dir_loc);
fclose(hom_dir_file);
copy_file(hom_dir_loc, target);
//Evaluate mutant
//Run make on the mutated project in order to build it
printf("--> Evaluating HOM: %s\n",hom_file_name);
//Open log file for recording mutation results
mutation_results = fopen(mutation_results_path,"a+");
fprintf(mutation_results, "\n**** Mutant: %s ****\n",hom_file_name);
fflush(mutation_results);
fclose(mutation_results);
mResult->homResult->total_mutants++;
//Get mutants killed by tests before new evaluation
int prev_killed_by_tests=get_non_trivial_FOM_stats()[0];
if(runMake(makeDir,hom_file_name,user_config->makeTestTarget)==2){
mResult->homResult->mutant_kill_count++;
}
//Get mutants killed by tests after evaluation
int *stats = get_non_trivial_FOM_stats();
if(stats[0]-prev_killed_by_tests==1){
mResult->homResult->mutant_kill_count++;
}
hom->fragility=((double)stats[1]/(double)stats[2]);
//Generate the fragility for all the set of FOMs that makeup this HOM
hashset_t test_killed_set = hashset_create();
if (test_killed_set == NULL) {
fprintf(stderr, "failed to create hashset instance\n");
abort();
}
int mut,c;
for(mut=0;mut<hom->FOMutants_count;mut++){
Mutant mutant = hom->FOMutants[mut];
for(c=0;c<mutant.killed_by_tests_count;c++){
hashset_add(test_killed_set, &mutant.killed_by_tests[c]);
}
}
hom->fitness=hom->fragility/(((double)hashset_num_items(test_killed_set)/(double)stats[2]));
hashset_destroy(test_killed_set);
return hom->fitness;
}
