string SRAssembler:: get_index_fasta_file_name(int round){ if (round > 1){ if (assembly_round < round) return get_contig_file_name(round-1); else { string joined_file = tmp_dir + "/output_matched_joined.fasta"; string cmd; for (unsigned i=0;i<this->libraries.size();i++){ string left_file = tmp_dir + "/output_matched_left_" + int2str(i) + ".fasta"; string right_file = tmp_dir + "/output_matched_right_" + int2str(i) + ".fasta"; if (libraries[i].get_file_extension() == "fastq") { fastq2fasta(tmp_dir + "/output_matched_left_" + int2str(i) + ".fastq", left_file); if (libraries[i].get_paired_end()) fastq2fasta(tmp_dir + "/output_matched_right_" + int2str(i) + ".fastq", right_file); } if (libraries[i].get_paired_end()){ cmd = "cat " + left_file + " " + right_file + " >> " + joined_file; logger->debug(cmd); run_shell_command(cmd); }else cmd = "cat " + left_file + " >> " + joined_file; logger->debug(cmd); run_shell_command(cmd); } return joined_file; } } return query_file; }
void cur_proj_set (GttProject *proj) { /* Due to the way the widget callbacks work, * we may be called recursively ... */ if (cur_proj == proj) return; log_proj(NULL); gtt_project_timer_stop (cur_proj); gtt_status_icon_stop_timer (proj); run_shell_command (cur_proj, FALSE); GttProject *old_prj = cur_proj; if (proj) { if (timer_is_running ()) { stop_main_timer (); } cur_proj = proj; gtt_project_timer_start (proj); gtt_status_icon_start_timer (proj); run_shell_command (cur_proj, TRUE); start_idle_timer (); start_main_timer (); } else { if (timer_is_running ()) { stop_main_timer (); } cur_proj = NULL; start_no_project_timer (); } log_proj(proj); if (old_prj) { gtt_projects_tree_update_project_data (projects_tree, old_prj); } if (cur_proj) { gtt_projects_tree_update_project_data (projects_tree, cur_proj); } /* update GUI elements */ menu_set_states(); toolbar_set_states(); if (proj) { prop_dialog_set_project(proj); notes_area_set_project (global_na, proj); } update_status_bar(); }
static void exec_proxy_cmd(void *user_data_cmd) { const char *cmd = user_data_cmd; char *usershell; usershell = m_strdup(get_user_shell()); run_shell_command(cmd, ses.maxfd, usershell); dropbear_exit("Failed to run '%s'\n", cmd); }
void SRAssembler::merge_mapped_files(int round){ for (unsigned int lib_idx=0;lib_idx<this->libraries.size();lib_idx++){ Library lib = this->libraries[lib_idx]; logger->debug("Merge files..."); //copy reads we have so far, for debugging string left_files = tmp_dir + "/output_matched_left_" + int2str(round) + "_" + int2str(lib_idx + 1) + "_*"; string cmd = "cat " + left_files + " >> " + lib.get_matched_left_read_name(); logger->debug(cmd); run_shell_command(cmd); cmd = "rm -f " + left_files; logger->debug(cmd); run_shell_command(cmd); if (lib.get_paired_end()) { string right_files = tmp_dir + "/output_matched_right_" + int2str(round) + "_" + int2str(lib_idx + 1) + "_*"; cmd = "cat " + right_files + " >> " + lib.get_matched_right_read_name(); logger->debug(cmd); run_shell_command(cmd); cmd = "rm -f " + right_files; logger->debug(cmd); run_shell_command(cmd); } //cmd = "cat " + tmp_dir + "/output_matched_joined_" + int2str(round) + "_" + int2str(lib_idx) + "* > " + tmp_dir + "/output_matched_joined_" + int2str(round) + "_" + int2str(lib_idx) + ".fasta"; if (round > 1) run_shell_command("cp " + lib.get_matched_left_read_name() + " " + lib.get_matched_left_read_name(round)); if (lib.get_paired_end() && round > 1) run_shell_command("cp " + lib.get_matched_right_read_name() + " " + lib.get_matched_right_read_name(round)); } string cmd = "rm -f " + get_index_name(round) + ".*";; logger->debug(cmd); run_shell_command(cmd); logger->debug("done."); }
int SRAssembler::do_alignment(int round, int lib_idx, int idx) { Library lib = this->libraries[lib_idx]; logger->info("Aligning: round = " + int2str(round) + " Lib (" + int2str(lib_idx+1) + "/" + int2str(this->libraries.size()) + "), Reads (" + int2str(idx) + "/" + int2str(lib.get_num_parts()) + ")"); Aligner* aligner = get_aligner(round); string program_name = aligner->get_program_name(); if (round == 1) program_name += "_init"; Params params = this->read_param_file(program_name); aligner->do_alignment(get_index_name(round), get_type(round), get_match_length(round), get_mismatch_allowed(round), lib.get_split_file_name(idx, aligner->get_format()), params, get_output_file_name(round, lib_idx, idx)); int ret = aligner->parse_output(get_output_file_name(round, lib_idx, idx), mapped_reads, lib.get_split_file_name(idx, lib.get_format()), lib.get_matched_left_read_name(round, idx), lib.get_matched_right_read_name(round, idx), fastq_format, lib.get_format()); string cmd = "rm -f " + get_output_file_name(round, lib_idx, idx); save_mapped_reads(round); run_shell_command(cmd); return ret; }
void GSQAligner::do_spliced_alignment(const string& genomic_file, const string& type, const string& query_file, const string& species, const Params& params, const string& output_file, const string& hit_contig_file){ string param_list = ""; for ( Params::const_iterator it = params.begin(); it != params.end(); ++it ){ param_list += " -" + it->first + " " + it->second; } string type_str = "E"; string species_str = species_names[species]; if (species_str == "") species_str = "generic"; if (type == "protein") type_str = "Q"; string cmd = "GeneSeqer -L " + genomic_file + " -" + type_str + " " + query_file + " -species " + species_str + " " + param_list + " -o " + output_file + " >> " + logger->get_log_file() + " 2>&1"; logger->debug(cmd); run_shell_command(cmd); //get_aligned_contigs(genomic_file, hit_contig_file, output_file); }
int command_do_shell(int param) { return run_shell_command(NULL); }
u_char * var_extensible_relocatable(struct variable *vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { int i; int len; struct extensible *exten = 0; static long long_ret; static char errmsg[STRMAX]; char *cp, *cp1; struct variable myvp; oid tname[MAX_OID_LEN]; memcpy(&myvp, vp, sizeof(struct variable)); long_ret = *length; for (i = 1; i <= (int) numrelocs; i++) { exten = get_exten_instance(relocs, i); if (!exten) continue; if ((int) exten->miblen == (int) vp->namelen - 1) { memcpy(myvp.name, exten->miboid, exten->miblen * sizeof(oid)); myvp.namelen = exten->miblen; *length = vp->namelen; memcpy(tname, vp->name, vp->namelen * sizeof(oid)); if (!header_simple_table (&myvp, tname, length, -1, var_len, write_method, -1)) break; else exten = NULL; } } if (i > (int) numrelocs || exten == NULL) { *length = long_ret; *var_len = 0; *write_method = NULL; return (NULL); } *length = long_ret; if (header_simple_table(vp, name, length, exact, var_len, write_method, ((vp->magic == ERRORMSG) ? MAXMSGLINES : 1))) return (NULL); switch (vp->magic) { case MIBINDEX: long_ret = name[*length - 1]; return ((u_char *) (&long_ret)); case ERRORNAME: /* name defined in config file */ *var_len = strlen(exten->name); return ((u_char *) (exten->name)); case SHELLCOMMAND: *var_len = strlen(exten->command); return ((u_char *) (exten->command)); case ERRORFLAG: /* return code from the process */ len = sizeof(exten->output); if (exten->type == EXECPROC) exten->result = run_exec_command( exten->command, NULL, exten->output, &len); else exten->result = run_shell_command(exten->command, NULL, exten->output, &len); long_ret = exten->result; return ((u_char *) (&long_ret)); case ERRORMSG: /* first line of text returned from the process */ len = sizeof(exten->output); if (exten->type == EXECPROC) exten->result = run_exec_command( exten->command, NULL, exten->output, &len); else exten->result = run_shell_command(exten->command, NULL, exten->output, &len); /* * Pick the output string apart into individual lines, * and extract the one being asked for.... */ cp1 = exten->output; for (i = 1; i != (int) name[*length - 1]; i++) { cp = strchr(cp1, '\n'); if (!cp) { *var_len = 0; /* wait_on_exec(exten); ??? */ return NULL; } cp1 = ++cp; } /* * ... and quit if we've run off the end of the output */ if (!*cp1) { *var_len = 0; return NULL; } cp = strchr(cp1, '\n'); if (cp) *cp = 0; strlcpy(errmsg, cp1, sizeof(errmsg)); *var_len = strlen(errmsg); if (errmsg[*var_len - 1] == '\n') errmsg[--(*var_len)] = '\0'; return ((u_char *) (errmsg)); case ERRORFIX: *write_method = fixExecError; long_return = 0; return ((u_char *) & long_return); case ERRORFIXCMD: *var_len = strlen(exten->fixcmd); return ((u_char *) exten->fixcmd); } return NULL; }
u_char * var_extensible_shell(struct variable * vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { static struct extensible *exten = 0; static long long_ret; int len; if (header_simple_table (vp, name, length, exact, var_len, write_method, numextens)) return (NULL); if ((exten = get_exten_instance(extens, name[*length - 1]))) { switch (vp->magic) { case MIBINDEX: long_ret = name[*length - 1]; return ((u_char *) (&long_ret)); case ERRORNAME: /* name defined in config file */ *var_len = strlen(exten->name); return ((u_char *) (exten->name)); case SHELLCOMMAND: *var_len = strlen(exten->command); return ((u_char *) (exten->command)); case ERRORFLAG: /* return code from the process */ len = sizeof(exten->output); if (exten->type == EXECPROC) { exten->result = run_exec_command( exten->command, NULL, exten->output, &len); } else { exten->result = run_shell_command(exten->command, NULL, exten->output, &len); } long_ret = exten->result; return ((u_char *) (&long_ret)); case ERRORMSG: /* first line of text returned from the process */ len = sizeof(exten->output); if (exten->type == EXECPROC) { exten->result = run_exec_command( exten->command, NULL, exten->output, &len); } else { exten->result = run_shell_command(exten->command, NULL, exten->output, &len); } *var_len = strlen(exten->output); if (exten->output[*var_len - 1] == '\n') exten->output[--(*var_len)] = '\0'; return ((u_char *) (exten->output)); case ERRORFIX: *write_method = fixExecError; long_return = 0; return ((u_char *) & long_return); case ERRORFIXCMD: *var_len = strlen(exten->fixcmd); return ((u_char *) exten->fixcmd); } return NULL; } return NULL; }
/** * * File associations hook * For details see about hook's on user documentation */ int _file_associations_hook (dynstruct_t *__callData) { extension_action_t *ext; wchar_t *executecmd, *filename, *cwd; if (dynstruct_get_field_val (__callData, L"filename", (void **) &filename) != DYNST_OK) { message_box (L"Hook `open-file-hook' error", L"variable `filename' not found", MB_OK|MB_CRITICAL); return HOOK_FAILURE; } filename = escape_string (filename); if (_get_file_associations (filename, (void *) &ext) != TCL_OK) { executecmd = filename; } else { if (dynstruct_get_field_val (__callData, L"cwd", (void **) &cwd) != DYNST_OK) { message_box (L"Hook `open-file-hook' error", L"variable `cwd' not found", MB_OK|MB_CRITICAL); return HOOK_FAILURE; } if (!ext->opener) { wchar_t msg[1024]; swprintf (msg, BUF_LEN (msg), _(L"There is no command specified to open file \"%ls\""), filename); MESSAGE_ERROR (msg); return HOOK_FAILURE; } cwd = escape_string (cwd); executecmd = prepare_exec_command (ext->opener, filename, cwd); SAFE_FREE (filename); SAFE_FREE (cwd); } if (run_shell_command (executecmd) == -1) { return HOOK_FAILURE; } SAFE_FREE (executecmd); return HOOK_SUCCESS; }
int run_exec_command( char *command, char *input, char *output, int *out_len) /* Or realloc style ? */ { #if HAVE_EXECV int ipipe[2]; int opipe[2]; int i; int pid; int result; char **argv; int argc; DEBUGMSGTL(("run:exec", "running '%s'\n", command)); pipe(ipipe); pipe(opipe); if ((pid = fork()) == 0) { /* * Child process */ /* * Set stdin/out/err to use the pipe * and close everything else */ close(0); dup( ipipe[0]); close(ipipe[1]); close(1); dup( opipe[1]); close(opipe[0]); close(2); dup(1); for (i = getdtablesize()-1; i>2; i--) close(i); /* * Set up the argv array and execute it * This is being run in the child process, * so will release resources when it terminates. */ argv = tokenize_exec_command( command, &argc ); execv( argv[0], argv ); perror( argv[0] ); exit(1); /* End of child */ } else if (pid > 0) { char cache[NETSNMP_MAXCACHESIZE]; char *cache_ptr; ssize_t count, cache_size, offset = 0; int waited = 0, numfds; fd_set readfds; struct timeval timeout; /* * Parent process */ /* * Pass the input message (if any) to the child, * wait for the child to finish executing, and read * any output into the output buffer (if provided) */ close(ipipe[0]); close(opipe[1]); if (input) { write(ipipe[1], input, strlen(input)); close(ipipe[1]); /* or flush? */ } else close(ipipe[1]); /* * child will block if it writes a lot of data and * fills up the pipe before exiting, so we read data * to keep the pipe empty. */ if (output && ((NULL == out_len) || (0 == *out_len))) { DEBUGMSGTL(("run:exec", "invalid params; no output will be returned\n")); output = NULL; } if (output) { cache_ptr = output; cache_size = *out_len - 1; } else { cache_ptr = cache; cache_size = sizeof(cache); } /* * xxx: some of this code was lifted from get_exec_output * in util_funcs.c. Probably should be moved to a common * routine for both to use. */ DEBUGMSGTL(("verbose:run:exec"," waiting for child %d...\n", pid)); numfds = opipe[0] + 1; i = NETSNMP_MAXREADCOUNT; for (; i; --i) { /* * set up data for select */ FD_ZERO(&readfds); FD_SET(opipe[0],&readfds); timeout.tv_sec = 1; timeout.tv_usec = 0; DEBUGMSGTL(("verbose:run:exec", " calling select\n")); count = select(numfds, &readfds, NULL, NULL, &timeout); if (count == -1) { if (EAGAIN == errno) continue; else { DEBUGMSGTL(("verbose:run:exec", " errno %d\n", errno)); setPerrorstatus("read"); break; } } else if (0 == count) { DEBUGMSGTL(("verbose:run:exec", " timeout\n")); continue; } if (! FD_ISSET(opipe[0], &readfds)) { DEBUGMSGTL(("verbose:run:exec", " fd not ready!\n")); continue; } /* * read data from the pipe, optionally saving to output buffer */ count = read(opipe[0], &cache_ptr[offset], cache_size); DEBUGMSGTL(("verbose:run:exec", " read %d bytes\n", (int)count)); if (0 == count) { int rc; /* * we shouldn't get no data, because select should * wait til the fd is ready. before we go back around, * check to see if the child exited. */ DEBUGMSGTL(("verbose:run:exec", " no data!\n")); if ((rc = waitpid(pid, &result, WNOHANG)) <= 0) { if (rc < 0) { snmp_log_perror("waitpid"); break; } else DEBUGMSGTL(("verbose:run:exec", " child not done!?!\n"));; } else { DEBUGMSGTL(("verbose:run:exec", " child done\n")); waited = 1; /* don't wait again */ break; } } else if (count > 0) { /* * got some data. fix up offset, if needed. */ if(output) { offset += count; cache_size -= count; if (cache_size <= 0) { DEBUGMSGTL(("verbose:run:exec", " output full\n")); break; } DEBUGMSGTL(("verbose:run:exec", " %d left in buffer\n", (int)cache_size)); } } else if ((count == -1) && (EAGAIN != errno)) { /* * if error, break */ DEBUGMSGTL(("verbose:run:exec", " errno %d\n", errno)); setPerrorstatus("read"); break; } } DEBUGMSGTL(("verbose:run:exec", " done reading\n")); if (output) DEBUGMSGTL(("run:exec", " got %d bytes\n", *out_len)); /* * close pipe to signal that we aren't listenting any more. */ close(opipe[0]); /* * if we didn't wait successfully above, wait now. * xxx-rks: seems like this is a waste of the agent's * time. maybe start a time to wait(WNOHANG) once a second, * and late the agent continue? */ if ((!waited) && (waitpid(pid, &result, 0) < 0 )) { snmp_log_perror("waitpid"); return -1; } /* * null terminate any output */ if (output) { output[offset] = 0; *out_len = offset; } DEBUGMSGTL(("run:exec"," child %d finished. result=%d\n", pid,result)); return WEXITSTATUS(result); } else { /* * Parent process - fork failed */ snmp_log_perror("fork"); close(ipipe[0]); close(ipipe[1]); close(opipe[0]); close(opipe[1]); return -1; } #else /* * If necessary, fall back to using 'system' */ DEBUGMSGTL(("run:exec", "running shell command '%s'\n", command)); return run_shell_command( command, input, output, out_len ); #endif }
/* * Trap handler for invoking a suitable script */ int command_handler( netsnmp_pdu *pdu, netsnmp_transport *transport, netsnmp_trapd_handler *handler) { #ifndef USING_UTILITIES_EXECUTE_MODULE NETSNMP_LOGONCE((LOG_WARNING, "support for run_shell_command not available\n")); return NETSNMPTRAPD_HANDLER_FAIL; #else u_char *rbuf = NULL; size_t r_len = 64, o_len = 0; int oldquick; DEBUGMSGTL(( "snmptrapd", "command_handler\n")); DEBUGMSGTL(( "snmptrapd", "token = '%s'\n", handler->token)); if (handler && handler->token && *handler->token) { netsnmp_pdu *v2_pdu = NULL; if (pdu->command == SNMP_MSG_TRAP) v2_pdu = convert_v1pdu_to_v2(pdu); else v2_pdu = pdu; oldquick = snmp_get_quick_print(); snmp_set_quick_print(1); /* * Format the trap and pass this string to the external command */ if ((rbuf = (u_char *) calloc(r_len, 1)) == NULL) { snmp_log(LOG_ERR, "couldn't display trap -- malloc failed\n"); return NETSNMPTRAPD_HANDLER_FAIL; /* Failed but keep going */ } /* * If there's a format string registered for this trap, then use it. * Otherwise use the standard execution format setting. */ if (handler && handler->format && *handler->format) { DEBUGMSGTL(( "snmptrapd", "format = '%s'\n", handler->format)); realloc_format_trap(&rbuf, &r_len, &o_len, 1, handler->format, v2_pdu, transport); } else { if ( pdu->command == SNMP_MSG_TRAP && exec_format1 ) { DEBUGMSGTL(( "snmptrapd", "exec v1 = '%s'\n", exec_format1)); realloc_format_trap(&rbuf, &r_len, &o_len, 1, exec_format1, pdu, transport); } else if ( pdu->command != SNMP_MSG_TRAP && exec_format2 ) { DEBUGMSGTL(( "snmptrapd", "exec v2/3 = '%s'\n", exec_format2)); realloc_format_trap(&rbuf, &r_len, &o_len, 1, exec_format2, pdu, transport); } else { DEBUGMSGTL(( "snmptrapd", "execute format\n")); realloc_format_trap(&rbuf, &r_len, &o_len, 1, EXECUTE_FORMAT, v2_pdu, transport); } } /* * and pass this formatted string to the command specified */ run_shell_command(handler->token, (char*)rbuf, NULL, NULL); /* Not interested in output */ snmp_set_quick_print(oldquick); if (pdu->command == SNMP_MSG_TRAP) snmp_free_pdu(v2_pdu); free(rbuf); } return NETSNMPTRAPD_HANDLER_OK; #endif /* !def USING_UTILITIES_EXECUTE_MODULE */ }
void SRAssembler::do_preprocessing(int lib_idx, int file_part){ Library lib = this->libraries[lib_idx]; logger->info("preprocessing lib " + int2str(lib_idx + 1) + ", reads file (" + int2str(file_part) + "/" + int2str(lib.get_num_parts()) + ")"); char suffixc[3]; suffixc[0] = (char)(((file_part-1) / 26) + 97); suffixc[1] = (char)(((file_part-1) % 26) + 97); suffixc[2] = '\0'; string suffix(suffixc); string left_src_read = lib.get_prefix_split_src_file(lib.get_left_read()) + suffix; string right_src_read = ""; if (lib.get_paired_end()) right_src_read = lib.get_prefix_split_src_file(lib.get_right_read()) + suffix; ifstream left_file(left_src_read.c_str()); ifstream right_file; if (lib.get_paired_end()){ right_file.open(right_src_read.c_str(), ios_base::in); } string left_header = ""; string right_header = ""; string left_seq = ""; string right_seq = ""; string left_qual = ""; string right_qual = ""; string plus; ofstream split_read_fasta_file; ofstream split_read_fastq_file; split_read_fasta_file.open(lib.get_split_file_name(file_part, FORMAT_FASTA).c_str(), ios_base::out); if (lib.get_format() == FORMAT_FASTQ) split_read_fastq_file.open(lib.get_split_file_name(file_part, FORMAT_FASTQ).c_str(), ios_base::out); while (getline(left_file, left_header)) { // get read data point, which includes 4 lines string lead_chr = (lib.get_format() == FORMAT_FASTQ)? "@" : ">"; if (left_header.substr(0,1) == lead_chr){ //save left-end reads getline(left_file, left_seq); if (lib.get_format() == FORMAT_FASTQ) { getline(left_file, plus); getline(left_file, left_qual); } if (lib.get_paired_end()){ //save right-end reads while (getline(right_file, right_header)) if (right_header.substr(0,1) == lead_chr) break; getline(right_file, right_seq); if (lib.get_format() == FORMAT_FASTQ) { getline(right_file, plus); getline(right_file, right_qual); } } if (lib.get_format() == FORMAT_FASTQ) { split_read_fastq_file << left_header << endl << left_seq << endl << "+" << endl << left_qual << endl; } split_read_fasta_file << ">" << left_header.substr(1) << endl << left_seq << endl; if (lib.get_paired_end()){ if (lib.get_format() == FORMAT_FASTQ) { split_read_fastq_file << right_header << endl << right_seq << endl << "+" << endl << right_qual << endl; } split_read_fasta_file << ">" << right_header.substr(1) << endl << right_seq << endl; } } } split_read_fasta_file.close(); if (lib.get_format() == FORMAT_FASTQ) split_read_fastq_file.close(); left_file.close(); if (lib.get_paired_end()) right_file.close(); string cmd = "rm " + left_src_read + " " + right_src_read; run_shell_command(cmd); }