int main(int args, char** argsv)
{
char root_route[] = "/";
char ping_route[] = "/ping";
configuration config;
config.http_listen_address = "0.0.0.0";
struct opt_config *conf;
conf = opt_config_init();
opt_flag_int(conf, &config.http_listen_port, "port", 8000, "Port to listen on.");
opt_flag_int(conf, &config.thread_count, "threads", 0, "Number of threads to use.");
opt_flag_string(conf, &config.parser, "parser", "http_parser", "HTTP parser to use");
opt_flag_int(conf, &config.max_request_size, "max_request_size", 1048576, "Maximum request size. Defaults to 1MB.");
opt_flag_bool(conf, &config.tcp_nodelay, "tcp_nodelay", "If present, enables tcp_nodelay (i.e. disables Nagle's algorithm).");
opt_flag_int(conf, &config.listen_backlog, "listen_backlog", 0, "Maximum size of the backlog when accepting connection. Defaults to SOMAXCONN.");
args = opt_config_parse(conf, args, argsv);
hw_init_with_config(&config);
hw_http_add_route(ping_route, get_ping, NULL);
hw_http_add_route(root_route, get_root, NULL);
hw_http_open();
opt_config_free(conf);
return 0;
}
int main(int argc, char **argv){
FILE *query_file = NULL, *test_hits_file = NULL;
struct cb_database_r *db = NULL;
struct opt_config *conf;
struct opt_args *args;
struct DSVector *iterations = NULL, *expanded_hits = NULL, *queries = NULL,
*oseqs = ds_vector_create();
struct fasta_seq *query = NULL;
xmlDoc *doc = NULL;
xmlNode *root = NULL;
uint64_t dbsize = 0;
int i = 0, j = 0;
conf = load_search_args();
args = opt_config_parse(conf, argc, argv);
if (args->nargs < 2) {
fprintf(stderr,
"Usage: %s [flags] database-dir fasta-file "
"[ --blast_args BLASTN_ARGUMENTS ]\n", argv[0]);
opt_config_print_usage(conf);
exit(1);
}
system("rm CaBLAST_results.xml");
if (!search_flags.hide_progress)
fprintf(stderr, "Loading database data\n\n");
db = cb_database_r_init(args->args[0],
(search_flags.load_coarse_db ||
search_flags.load_coarse_residues),
(search_flags.load_coarse_db ||
search_flags.load_coarse_links),
search_flags.load_compressed_db,
search_flags.link_block_size);
dbsize = read_int_from_file(8, db->coarse_db->db->file_params);
if (!search_flags.hide_progress)
fprintf(stderr, "Running coarse BLAST\n\n");
blast_coarse(args, dbsize);
if (NULL == (query_file = fopen(args->args[1], "r"))) {
fprintf(stderr, "fopen: 'fopen %s' failed: %s\n",
args->args[1], strerror(errno));
exit(1);
}
queries = ds_vector_create();
query = fasta_read_next(query_file, "");
while (query) {
ds_vector_append(queries, (void *)query);
query = fasta_read_next(query_file, "");
}
fclose(query_file);
if (!search_flags.hide_progress)
fprintf(stderr, "Processing coarse BLAST hits for fine BLAST\n\n");
if (search_flags.show_hit_info)
if (NULL == (test_hits_file = fopen("CaBLAST_hits.txt", "w"))) {
fprintf(stderr, "fopen: 'fopen %s' failed: %s\n",
"CaBLAST_hits.txt", strerror(errno));
exit(1);
}
//Parse the XML file generated from coarse BLAST and get its iterations.
doc = xmlReadFile("CaBLAST_temp_blast_results.xml", NULL, 0);
if (doc == NULL) {
fprintf(stderr, "Could not parse CaBLAST_temp_blast_results.xml\n");
return 0;
}
root = xmlDocGetRootElement(doc);
iterations = get_blast_iterations(root);
for (i = 0; i < iterations->size; i++) {
if (!search_flags.hide_progress) {
int32_t digits_full = floor(log10((double)iterations->size)),
digits_i = floor(log10((double)i)), spaces;
char *bar = progress_bar(i, iterations->size);
spaces = digits_full - digits_i;
fprintf(stderr, "\r");
fprintf(stderr, "iteration: %d/%d", i+1, iterations->size);
for (j = 0; j < spaces; j++)
putc(' ', stderr);
fprintf(stderr, " %s ", bar);
free(bar);
}
/*Expand any BLAST hits we got from the current query sequence during
coarse BLAST.*/
expanded_hits = expand_blast_hits(iterations, i, db);
for (j = 0; j < expanded_hits->size; j++)
ds_vector_append(oseqs, ds_vector_get(expanded_hits, j));
ds_vector_free_no_data(expanded_hits);
}
write_fine_fasta(oseqs);
for (i = 0; i < oseqs->size; i++)
cb_hit_expansion_free(
(struct cb_hit_expansion *)ds_vector_get(oseqs, i));
ds_vector_free_no_data(oseqs);
blast_fine(args, dbsize);
if (!search_flags.hide_progress)
fprintf(stderr, "\n"); //Make a newline after the progress bar
for (i = 0; i < queries->size; i++)
fasta_free_seq((struct fasta_seq *)ds_vector_get(queries, i));
ds_vector_free_no_data(queries);
if (search_flags.show_hit_info)
fclose(test_hits_file);
//Free the XML data and expanded hits
for (i = 0; i < iterations->size; i++) {
struct DSVector *iteration =
(struct DSVector *)ds_vector_get(iterations, i);
for (j = 0; j < iteration->size; j++) {
struct hit *h = (struct hit *)ds_vector_get(iteration, j);
ds_vector_free(h->hsps);
free(h);
}
}
ds_vector_free_no_data(iterations);
cb_database_r_free(db);
xmlFreeDoc(doc);
/*Free the coarse BLAST results file if the --no-cleanup flag is not being
used.*/
if (!search_flags.no_cleanup)
system("rm CaBLAST_temp_blast_results.xml");
opt_args_free(args);
opt_config_free(conf);
return 0;
}
int main(int argc, char **argv){
struct cb_database_r *db;
struct fasta_seq_gen *fsg;
struct fasta_seq *seq;
struct timeval start;
struct fasta_seq **coarse_sequences;
struct cb_link_to_coarse *link;
struct opt_config *conf = load_compress_args();
struct cb_compressed_seq **compressed;
uint64_t last_end, num_coarse_sequences = 0;
int i, org_seq_id, overlap;
char *fasta_filename, *compressed_filename;
FILE *compressed_file;
struct opt_args *args = opt_config_parse(conf, argc, argv);
if (args->nargs < 2) {
fprintf(stderr, "Usage: %s [flags] database-dir output-fasta-file\n",
argv[0]);
exit(1);
}
db = cb_database_r_init(args->args[0], false, false, false, 30000);
org_seq_id = 0;
gettimeofday(&start, NULL);
fasta_filename = path_join(args->args[0], CABLAST_COARSE_FASTA);
compressed_filename = path_join(args->args[0], CABLAST_COMPRESSED);
if (NULL == (compressed_file = fopen(compressed_filename, "r"))) {
fprintf(stderr, "fopen: 'fopen %s' failed: %s\n",
compressed_filename, strerror(errno));
exit(1);
}
compressed = read_compressed(compressed_file);
coarse_sequences = malloc(10000*sizeof(*coarse_sequences));
assert(coarse_sequences);
fsg = fasta_generator_start(fasta_filename, "", 100);
while (NULL != (seq = fasta_generator_next(fsg)))
coarse_sequences[num_coarse_sequences++] = seq;
for (i = 0; compressed[i] != NULL; i++) {
int current_chunk = 0;
last_end = 0;
printf(">%s\n", compressed[i]->name);
for (link = (compressed[i])->links; link != NULL; link = link->next) {
struct cb_seq *chunk =
cb_seq_init_range(-1, "",
coarse_sequences[link->coarse_seq_id]->seq,
link->coarse_start, link->coarse_end + 1);
int length;
char *decompressed;
/*overlap represents the length of the overlap of the parts of the
decompressed sequence that has been printed and the parts of the
decompressed sequence currently being decompressed.*/
overlap = last_end - link->original_start;
for (length = 0; chunk->residues[length] != '\0'; length++);
decompressed = read_edit_script(link->diff,chunk->residues,length);
/*Print all characters of the decompressed chunk past the index
*"overlap" unless overlap is greater than the length of the
*decompressed chunk.
*/
decompressed += overlap;
if (overlap < link->original_end - link->original_start ||
(overlap == link->original_end - link->original_start &&
!link->next))
printf("%s", decompressed);
decompressed -= overlap;
free(decompressed);
if (link->original_end > last_end)
last_end = link->original_end + 1;
cb_seq_free(chunk);
current_chunk++;
}
putc('\n', stdout);
}
free(fasta_filename);
free(compressed_filename);
for (i = 0; compressed[i] != NULL; i++)
cb_compressed_seq_free(compressed[i]);
free(compressed);
fasta_generator_free(fsg);
for (i = 0; i < num_coarse_sequences; i++)
free(coarse_sequences[i]);
free(coarse_sequences);
cb_database_r_free(db);
opt_config_free(conf);
opt_args_free(args);
return 0;
}
