[Bio] / FortyEight / check_jobs_ross.pl Repository:
ViewVC logotype

Annotation of /FortyEight/check_jobs_ross.pl

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1 - (view) (download) (as text)

1 : overbeek 1.1
2 :    
3 :     =head1 check_jobs.pl
4 :    
5 :     Check the status of the jobs in the 48-hour run queue to see if any
6 :     action should be taken.
7 :    
8 :     Actions taken are determined based on the metadata kept in meta.xml.
9 :    
10 :     We do a quick check by looking for the file ACTIVE in the job directory.
11 :     If this file does not exist, the job should not be considered.
12 :    
13 :     =cut
14 :    
15 :    
16 :     use strict;
17 :     use FIG;
18 :     use FIG_Config;
19 :     use GenomeMeta;
20 :     use Data::Dumper;
21 :     use Tracer;
22 :     use Job48;
23 :     use Mail::Mailer;
24 :     use Mantis;
25 :     use Filesys::DfPortable;
26 :    
27 :     TSetup("2 main FIG", "TEXT");
28 :    
29 :     my $job_spool_dir = $FIG_Config::fortyeight_jobs;
30 :    
31 :     #
32 :     # Verify we have at least 10G of space left.
33 :     #
34 :    
35 :     my $df = dfportable($job_spool_dir, 1024*1024*1024);
36 :     if (!defined($df))
37 :     {
38 :     die "dfportable call failed on $job_spool_dir: $!";
39 :     }
40 :     if ($df->{bavail} < 10)
41 :     {
42 :     die sprintf "Not enough free space available (%.1f GB) in $job_spool_dir", $df->{bavail};
43 :     }
44 :    
45 :     #my $sims_data_dir = "/scratch/48-hour/Data";
46 :     #my $sims_data_dir = "/vol/48-hour/Data";
47 :    
48 :     my $sims_data_dir = $FIG_Config::fortyeight_data;
49 :    
50 :     my $sims_nr = "$sims_data_dir/nr";
51 :     my $sims_peg_synonyms = "$sims_data_dir/peg.synonyms";
52 :     my $sims_keep_count = 300;
53 :    
54 :     opendir(D, $job_spool_dir) or die "Cannot open job directory $job_spool_dir: $!\n";
55 :    
56 :     my $qstat = read_qstat();
57 :     #print Dumper($qstat);
58 :     #exit;
59 :    
60 :     my @jobs = sort { $a <=> $b } grep { /^\d+$/ and -d "$job_spool_dir/$_" } readdir(D);
61 :    
62 :     for my $job (@jobs)
63 :     {
64 :     check_job($job, "$job_spool_dir/$job");
65 :     }
66 :    
67 :     sub check_job
68 :     {
69 :     my($job_id, $job_dir) = @_;
70 :     Trace("Checking $job_id at $job_dir\n") if T(1);
71 :    
72 :     if (! -f "$job_dir/ACTIVE")
73 :     {
74 :     Trace("Skipping job $job_id as not active\n") if T(2);
75 :     return;
76 :     }
77 :    
78 :     if (-f "$job_dir/DONE")
79 :     {
80 :     Trace("Skipping job $job_id as done\n") if T(2);
81 :     return;
82 :     }
83 :    
84 :     if (! -d "$job_dir/sge_output")
85 :     {
86 :     mkdir "$job_dir/sge_output";
87 :     }
88 :    
89 :     my $genome = &FIG::file_head("$job_dir/GENOME_ID", 1);
90 :     if (!$genome)
91 :     {
92 :     Trace("Skipping job $job_id: no GENOME_ID\n");
93 :     return;
94 :     }
95 :     chomp $genome;
96 :     print "Genome is $genome\n";
97 :    
98 :     my $meta = new GenomeMeta($genome, "$job_dir/meta.xml");
99 :    
100 :     if (!$meta)
101 :     {
102 :     Confess("Could not create meta for $genome $job_dir/meta.xml");
103 :     return;
104 :     }
105 :    
106 :     #
107 :     # Now go through the stages of life for a genome dir.
108 :     #
109 :    
110 :     if ($meta->get_metadata("status.uploaded") ne "complete")
111 :     {
112 :     process_upload();
113 :     return;
114 :     }
115 :    
116 :     #
117 :     # If rapid progation is not complete, schedule it, unless it
118 :     # had errored. In any event, if it's not complete, do not proceed.
119 :     #
120 :     if ($meta->get_metadata("status.rp") ne "complete")
121 :     {
122 :     if ($meta->get_metadata("status.rp") ne "error")
123 :     {
124 :     process_rp($genome, $job_id, $job_dir, $meta);
125 :     }
126 :     else
127 :     {
128 :     flag_error($genome, $job_id, $job_dir, $meta, "rp");
129 :     }
130 :    
131 :     return;
132 :     }
133 :    
134 :     #
135 :     # We do not touch the QC or correction phases if keep_genecalls is enabled.
136 :     #
137 :     my $keep_genecalls = $meta->get_metadata("keep_genecalls");
138 :    
139 :     if ($meta->get_metadata("status.qc") ne "complete")
140 :     {
141 :     if ($keep_genecalls)
142 :     {
143 :     $meta->add_log_entry($0, "keep_genecalls is enabled: marking qc as complete");
144 :     $meta->set_metadata("status.qc", "complete");
145 :     }
146 :     elsif ($meta->get_metadata("status.qc") ne "error")
147 :     {
148 :     process_qc($genome, $job_id, $job_dir, $meta);
149 :     }
150 :     else
151 :     {
152 :     flag_error($genome, $job_id, $job_dir, $meta, "qc");
153 :     }
154 :    
155 :     return;
156 :     }
157 :    
158 :     #
159 :     # See if we need to perform correction.
160 :     #
161 :    
162 :     my $cor_status = $meta->get_metadata("status.correction");
163 :    
164 :     if ($cor_status ne 'complete')
165 :     {
166 :     if ($keep_genecalls)
167 :     {
168 :     $meta->add_log_entry($0, "keep_genecalls is enabled: marking correction as complete");
169 :     $meta->set_metadata("status.correction", "complete");
170 :     }
171 :     elsif ($cor_status ne "error" and $cor_status ne 'requires_intervention')
172 :     {
173 :     my $req = $meta->get_metadata("correction.request");
174 :     process_correction($genome, $job_id, $job_dir, $meta, $req);
175 :     }
176 :     elsif ($cor_status eq 'error')
177 :     {
178 :     flag_error($genome, $job_id, $job_dir, $meta, "correction");
179 :     }
180 :     return;
181 :     }
182 :    
183 :     #
184 :     # Determine if we have no errors that require user intervention.
185 :     #
186 :    
187 :     # if ($meta->get_metadata("status.stoplight") ne "complete")
188 :     # {
189 :     # check_qc_status_for_intervention($genome, $job_id, $job_dir, $meta, $req);
190 :     # }
191 :    
192 :     #
193 :     # User interaction stoplight stuff must have completed for us to proceed.
194 :     #
195 :     # if ($meta->get_metadata("status.stoplight") ne "complete")
196 :     # {
197 :     # return;
198 :     # }
199 :    
200 :     if ((my $sim_status = $meta->get_metadata("status.sims")) ne "complete")
201 :     {
202 :     if ($sim_status ne "error")
203 :     {
204 :     process_sims($genome, $job_id, $job_dir, $meta);
205 :     }
206 :     else
207 :     {
208 :     flag_error($genome, $job_id, $job_dir, $meta, "sims");
209 :     }
210 :     return;
211 :     }
212 :    
213 :     if ((my $sim_status = $meta->get_metadata("status.bbhs")) ne "complete")
214 :     {
215 :     if ($sim_status ne "error")
216 :     {
217 :     process_bbhs($genome, $job_id, $job_dir, $meta);
218 :     }
219 :     else
220 :     {
221 :     flag_error($genome, $job_id, $job_dir, $meta, "bbhs");
222 :     }
223 :     return;
224 :     }
225 :    
226 :     if ((my $aa_status = $meta->get_metadata("status.auto_assign")) ne "complete")
227 :     {
228 :     if ($aa_status ne "error")
229 :     {
230 :     process_auto_assign($genome, $job_id, $job_dir, $meta);
231 :     }
232 :     else
233 :     {
234 :     flag_error($genome, $job_id, $job_dir, $meta, "auto_assign");
235 :     }
236 :     return;
237 :     }
238 :    
239 :     if ((my $aa_status = $meta->get_metadata("status.glue_contigs")) ne "complete")
240 :     {
241 :     if ($aa_status ne "error")
242 :     {
243 :     process_glue_contigs($genome, $job_id, $job_dir, $meta);
244 :     }
245 :     else
246 :     {
247 :     flag_error($genome, $job_id, $job_dir, $meta, "glue_contigs");
248 :     }
249 :     return;
250 :     }
251 :    
252 :     if ((my $pch_status = $meta->get_metadata("status.pchs")) ne "complete")
253 :     {
254 :     if ($pch_status ne "error")
255 :     {
256 :     process_pchs($genome, $job_id, $job_dir, $meta);
257 :     }
258 :     else
259 :     {
260 :     flag_error($genome, $job_id, $job_dir, $meta, "pchs");
261 :     }
262 :     return;
263 :     }
264 :    
265 :     if ((my $scenario_status = $meta->get_metadata("status.scenario")) ne "complete")
266 :     {
267 :     if ($scenario_status ne "error")
268 :     {
269 :     process_scenario($genome, $job_id, $job_dir, $meta);
270 :     }
271 :     else
272 :     {
273 :     flag_error($genome, $job_id, $job_dir, $meta, "scenario");
274 :     }
275 :     return;
276 :     }
277 :    
278 :     #
279 :     # Here marks the end of the stock processing stages. Anything beyond is triggered
280 :     # only if this genome is marked for inclusion into the SEED.
281 :     #
282 :    
283 :     if ($meta->get_metadata("status.final") ne "complete")
284 :     {
285 :     mark_job_user_complete($genome, $job_id, $job_dir, $meta);
286 :     }
287 :    
288 :     #
289 :     # If the job is marked as a JGI candidate, let it flow past. If not, we need
290 :     # to do more thorough checks on seed submission status.
291 :     #
292 :    
293 :     if (not $meta->get_metadata("submit.JGI"))
294 :     {
295 :    
296 :     #
297 :     # If this job is not even a candidate for seed inclusion, mark it as completely done.
298 :     #
299 :    
300 :     if (not ($meta->get_metadata("submit.suggested") or $meta->get_metadata("submit.candidate")))
301 :     {
302 :     print "Job not a candidate, marking as done\n";
303 :     mark_job_done($genome, $job_id, $job_dir, $meta);
304 :     return;
305 :     }
306 :    
307 :     #
308 :     # The job was a candidate. If it has been rejected (submit.never is set), mark it completely done.
309 :     #
310 :    
311 :     if ($meta->get_metadata("submit.never"))
312 :     {
313 :     print "Job rejected, marking as done\n";
314 :     mark_job_done($genome, $job_id, $job_dir, $meta);
315 :     return;
316 :     }
317 :    
318 :    
319 :     #
320 :     # If the job has not yet been approved, just return and check again later.
321 :     #
322 :    
323 :     if (not($meta->get_metadata("submit.seed") or $meta->get_metadata("submit.nmpdr")))
324 :     {
325 :     print "Job not yet checked, returning\n";
326 :     return;
327 :     }
328 :    
329 :     #
330 :     # Otherwise, it's an approved candidate, and we can go ahead and process.
331 :     #
332 :     print "Continuing\n";
333 :     }
334 :    
335 :     #
336 :     # Perform Glimmer and Critica calls if marked for JGI-teach inclusion.
337 :     #
338 :    
339 :     if ($meta->get_metadata("submit.JGI"))
340 :     {
341 :     if ((my $glimmer_status = $meta->get_metadata("status.glimmer")) ne "complete")
342 :     {
343 :     if ($glimmer_status ne "error")
344 :     {
345 :     process_glimmer($genome, $job_id, $job_dir, $meta);
346 :     }
347 :     else
348 :     {
349 :     flag_error($genome, $job_id, $job_dir, $meta, "glimmer");
350 :     }
351 :     return;
352 :     }
353 :     if ((my $critica_status = $meta->get_metadata("status.critica")) ne "complete")
354 :     {
355 :     if ($critica_status ne "error")
356 :     {
357 :     process_critica($genome, $job_id, $job_dir, $meta);
358 :     }
359 :     else
360 :     {
361 :     flag_error($genome, $job_id, $job_dir, $meta, "critica");
362 :     }
363 :     return;
364 :     }
365 :     }
366 :    
367 :     if ((my $pfam_status = $meta->get_metadata("status.pfam")) ne "complete")
368 :     {
369 :     if ($pfam_status ne "error")
370 :     {
371 :     process_pfam($genome, $job_id, $job_dir, $meta);
372 :     }
373 :     else
374 :     {
375 :     flag_error($genome, $job_id, $job_dir, $meta, "pfam");
376 :     }
377 :     return;
378 :     }
379 :    
380 :     # if ((my $cello_status = $meta->get_metadata("status.cello")) ne "complete")
381 :     # {
382 :     # if ($cello_status ne "error")
383 :     # {
384 :     # process_cello($genome, $job_id, $job_dir, $meta);
385 :     # }
386 :     # else
387 :     # {
388 :     # flag_error($genome, $job_id, $job_dir, $meta, "cello");
389 :     # }
390 :     # return;
391 :     # }
392 :    
393 :     # if ((my $phobius_status = $meta->get_metadata("status.phobius")) ne "complete")
394 :     # {
395 :     # if ($phobius_status ne "error")
396 :     # {
397 :     # process_phobius($genome, $job_id, $job_dir, $meta);
398 :     # }
399 :     # else
400 :     # {
401 :     # flag_error($genome, $job_id, $job_dir, $meta, "phobius");
402 :     # }
403 :     # return;
404 :     # }
405 :    
406 :    
407 :     #
408 :     # This job is done.
409 :     #
410 :    
411 :     mark_job_done($genome, $job_id, $job_dir, $meta);
412 :     }
413 :    
414 :     #
415 :     # Flag an error.
416 :     #
417 :     # This will send an email to the user notifying them that their job had
418 :     # an error; it copies the rast list in order to alert them that
419 :     # such an error occurred.
420 :     #
421 :     sub flag_error
422 :     {
423 :     my($genome, $job_id, $job_dir, $meta, $stage) = @_;
424 :    
425 :     my $msg;
426 :     if ($stage eq 'rp')
427 :     {
428 :     #
429 :     # Hunt down some more details on the error.
430 :     #
431 :    
432 :     my $err = $meta->get_metadata("rp.error");
433 :    
434 :     if ($err =~ /raw genome directory.*does not exist/ or
435 :     $err =~ /Unformatted contigs file.*does not exists/)
436 :     {
437 :     $msg = "An error occurred during the upload of your data.";
438 :     }
439 :     elsif ($err =~ /reformat command failed/)
440 :     {
441 :     my $f = &FIG::file_read("$job_dir/rp.errors/reformat_contigs_split.stderr");
442 :     if ($f =~ /File does not appear to be in FASTA/)
443 :     {
444 :     $msg = "An error occurred during the parsing of your input file.";
445 :     }
446 :     else
447 :     {
448 :     $msg = "An error occurred during the upload of your data.";
449 :     }
450 :     }
451 :     elsif ($err =~ /rapid_propagation command failed/ or
452 :     $err =~ /rapid_propagation did not create any features/)
453 :     {
454 :     $msg = "An error occurred during the annotation of your data.";
455 :     }
456 :     elsif (-f "$job_dir/rp.errors/find_neighbors_using_figfams.stderr")
457 :     {
458 :     my $ff = &FIG::file_read("$job_dir/rp.errors/find_neighbors_using_figfams.stderr");
459 :     if ($ff =~ /Could not find any features of sufficient length/)
460 :     {
461 :     $msg = "RAST processing could not determine the phylogenetic neighborhood of your genome.\n";
462 :     $msg .= "This may mean the genome was a fragment too small for RAST processing to be effective.";
463 :     }
464 :     }
465 :     }
466 :     elsif ($stage eq 'qc')
467 :     {
468 :     $msg = "An error occurred during the quality check phase of your genome's analysis.";
469 :     }
470 :     elsif ($stage eq 'sims')
471 :     {
472 :     $msg = "An error occurred during the similarity computation phase of your genome's analysis.";
473 :     }
474 :     elsif ($stage eq 'bbhs')
475 :     {
476 :     $msg = "An error occurred during the BBH computation phase of your genome's analysis.";
477 :     }
478 :     elsif ($stage eq 'auto_assign')
479 :     {
480 :     $msg = "An error occurred during the automated assignment phase of your genome's analysis.";
481 :     }
482 :     elsif ($stage eq 'glue_contings')
483 :     {
484 :     $msg = "An error occurred during the postprocessing phase of your genome's analysis.";
485 :     }
486 :     elsif ($stage eq 'pchs')
487 :     {
488 :     $msg = "An error occurred during the coupling computation phase of your genome's analysis.";
489 :     }
490 :     elsif ($stage eq 'scenario')
491 :     {
492 :     $msg = "An error occurred during the scenario computation phase of your genome's analysis.";
493 :     }
494 :    
495 :     if (!$msg)
496 :     {
497 :     $msg = "An error occurred during the analysis of your genome.";
498 :     }
499 :    
500 :     #
501 :     # Use the mantis info if there to figure out what server this is.
502 :     #
503 :    
504 :     my $server_info;
505 :     if (my $mi = $FIG_Config::mantis_info)
506 :     {
507 :     my $system = $mi->{system};
508 :     my $server = $mi->{server_value};
509 :     $server_info = " in the $system $server server"
510 :     }
511 :     else
512 :     {
513 :     $server_info = "";
514 :     }
515 :    
516 :     my $genome_name = &FIG::file_head("$job_dir/GENOME", 1);
517 :     chomp $genome_name;
518 :     my $body = <<END;
519 :     This message is regarding the RAST processing of your genome $genome_name, job number $job_id$server_info.
520 :    
521 :     $msg
522 :    
523 :     RAST developers will be investigating the cause of the error and possbily contacting
524 :     you for more information.
525 :     END
526 :    
527 :     if (open(E, ">$job_dir/ERROR"))
528 :     {
529 :     print E "$msg\n";
530 :     close(E);
531 :     }
532 :     $meta->set_metadata("genome.error", $msg);
533 :    
534 :     unlink("$job_dir/ACTIVE");
535 :    
536 :     my $job = new Job48($job_id);
537 :     my $userobj = $job->getUserObject();
538 :     my($email, $name);
539 :    
540 :     if ($userobj)
541 :     {
542 :     $email = $userobj->eMail();
543 :     $name = join(" " , $userobj->firstName(), $userobj->lastName());
544 :     }
545 :    
546 :     #
547 :     # if we are configured for Mantis integration, notify Mantis.
548 :     # But only if we are not the batch user.
549 :     #
550 :    
551 :     my($bug_id, $bug_url);
552 :     if ($FIG_Config::mantis_info and $job->user() ne 'batch')
553 :     {
554 :     eval {
555 :     my $mantis = Mantis->new($FIG_Config::mantis_info);
556 :    
557 :     ($bug_id, $bug_url) = $mantis->report_bug(stage => $stage,
558 :     genome => $genome,
559 :     genome_name => $genome_name,
560 :     job_id => $job_id,
561 :     job_dir => $job_dir,
562 :     user_email => $email,
563 :     user_name => $name,
564 :     meta => $meta,
565 :     msg => $msg);
566 :    
567 :     $body .= "\nBug report number $bug_id has been filed in the RAST bugtracking system for this error.\n";
568 :     $body .= "It may be viewed at the url $bug_url\n";
569 :     };
570 :     if ($@)
571 :     {
572 :     warn "Exception while reporting Mantis bug:\n$@\n";
573 :     }
574 :     }
575 :    
576 :     if ($meta->get_metadata("genome.error_notification_sent") ne "yes")
577 :     {
578 :     if ($email)
579 :     {
580 :     my $full = $name ? "$name <$email>" : $email;
581 :    
582 :     my $mail = Mail::Mailer->new();
583 :     $mail->open({
584 :     To => $full,
585 :     Cc => 'Annotation Server <rast@mcs.anl.gov>',
586 :     From => 'Annotation Server <rast@mcs.anl.gov>',
587 :     Subject => "RAST annotation server error on job $job_id",
588 :     });
589 :    
590 :     print $mail $body;
591 :     $mail->close();
592 :     $meta->set_metadata("genome.error_notification_sent", "yes");
593 :     $meta->set_metadata("genome.error_notification_time", time);
594 :     $meta->set_metadata("genome.error_notification_sent_address", $email);
595 :     }
596 :     }
597 :     }
598 :    
599 :    
600 :    
601 :    
602 :     #
603 :     # Hm, probably nothing we can really do here.
604 :     #
605 :     sub process_upload
606 :     {
607 :     return;
608 :     }
609 :    
610 :     =head2 process_rp
611 :    
612 :     Start or check status on the rapid propagation.
613 :    
614 :     =cut
615 :    
616 :     sub process_rp_old
617 :     {
618 :     my($genome, $job, $job_dir, $meta) = @_;
619 :    
620 :     #
621 :     # See if we have started running RP here.
622 :     #
623 :    
624 :     if ($meta->get_metadata("rp.running") eq 'yes')
625 :     {
626 :     Trace("RP is running for $job") if T(1);
627 :    
628 :     #
629 :     # Is the job now done?
630 :     #
631 :     my $sge_id = $meta->get_metadata("rp.sge_job_id");
632 :     my $status;
633 :    
634 :     if ($sge_id)
635 :     {
636 :     my $stat = $qstat->{$sge_id};
637 :     if ($stat)
638 :     {
639 :     for my $k (keys %$stat)
640 :     {
641 :     my $mdk = "rp.sge_status.$k";
642 :     my $cur = $meta->get_metadata($mdk);
643 :     if ($stat->{$k} ne $cur)
644 :     {
645 :     $meta->set_metadata($mdk, $stat->{$k});
646 :     }
647 :     }
648 :     }
649 :     else
650 :     {
651 :     $stat = { status => 'missing' };
652 :     }
653 :    
654 :     if ($stat->{status} eq 'r')
655 :     {
656 :     #
657 :     # see if queue or host has changed
658 :     #
659 :     my $q = $meta->get_metadata("rp.sge_status.queue");
660 :     my $h = $meta->get_metadata("rp.sge_status.host");
661 :     }
662 :     elsif ($stat->{status} eq 'qw')
663 :     {
664 :     $meta->set_metadata('status.rp', 'queued');
665 :     }
666 :     else
667 :     {
668 :     Trace("RP is done") if T(1);
669 :    
670 :     $meta->set_metadata("rp.running", "no");
671 :    
672 :     #
673 :     # Need to determine if run succeeded. We say it did if a
674 :     # genome dir got copied.
675 :     #
676 :    
677 :    
678 :     if (-d "$job_dir/rp/$genome")
679 :     {
680 :     $meta->set_metadata("status.rp", "complete");
681 :     }
682 :     else
683 :     {
684 :     $meta->set_metadata("status.rp", "error");
685 :     }
686 :     }
687 :     }
688 :    
689 :     return;
690 :     }
691 :     elsif ($meta->get_metadata('status.rp') eq 'queued')
692 :     {
693 :     Trace("RP queued") if T(1);
694 :     }
695 :    
696 :    
697 :     #
698 :     # Otherwise, set up for run and submit.
699 :     #
700 :    
701 :     my $tmp = "tmprp.$$";
702 :     my $tmpdir;
703 :    
704 :     $tmpdir = "/scratch/$tmp";
705 :     my $meta_file = $meta->get_file();
706 :    
707 :     my $errdir = "$job_dir/rp.errors";
708 :     &FIG::verify_dir($errdir);
709 :    
710 :     &FIG::verify_dir("$job_dir/rp");
711 :     my $cmd = "qsub -N rp_$job -e $job_dir/sge_output -o $job_dir/sge_output -v PATH -l fig_resource -b yes $FIG_Config::bin/rapid_propagation --errdir $errdir --meta $meta_file --tmpdir $tmpdir $job_dir/raw/$genome $job_dir/rp/$genome";
712 :     $meta->add_log_entry($0, $cmd);
713 :     if (!open(Q, "$cmd|"))
714 :     {
715 :     Confess("Qsub failed for job $job genome $genome in $job_dir: $!");
716 :     $meta->add_log_entry($0, "Qsub failed for job $job genome $genome in $job_dir: $!");
717 :     return;
718 :     }
719 :     my $sge_job_id;
720 :     while (<Q>)
721 :     {
722 :     if (/Your\s+job\s+(\d+)/)
723 :     {
724 :     $sge_job_id = $1;
725 :     }
726 :     }
727 :     if (!close(Q))
728 :     {
729 :     $meta->add_log_entry($0, "Qsub close failed: $!");
730 :     Confess("Qsub close failed: $!");
731 :     }
732 :    
733 :     if (!$sge_job_id)
734 :     {
735 :     $meta->add_log_entry($0, "did not get job id from qsub");
736 :     Confess("did not get job id from qsub");
737 :     }
738 :    
739 :     Trace("Submitted, job id is $sge_job_id") if T(1);
740 :    
741 :     $meta->set_metadata("rp.sge_job_id", $sge_job_id);
742 :     $meta->set_metadata("rp.start_time", time);
743 :     $meta->set_metadata("rp.running", "yes");
744 :     $meta->set_metadata("status.rp", "queued");
745 :     }
746 :    
747 :     sub read_qstat
748 :     {
749 :     if (!open(Q, "qstat -f -s prs |"))
750 :     {
751 :     warn "Could not read queue status: $!\n";
752 :     return;
753 :     }
754 :    
755 :     my $qstat = {};
756 :     my $finished;
757 :     my $queue;
758 :     my $host;
759 :     while (<Q>)
760 :     {
761 :    
762 :     if (/FINISHED JOBS/)
763 :     {
764 :     $finished++;
765 :     undef $queue;
766 :     undef $host;
767 :     next;
768 :     }
769 :     if (/^([^@]+)@(\S+)/)
770 :     {
771 :     $queue = $1;
772 :     $host = $2;
773 :     }
774 :     elsif (/^----/)
775 :     {
776 :     undef $queue;
777 :     undef $host;
778 :     }
779 :    
780 :     if (/^\s+(\d+)\s+(.*)/)
781 :     {
782 :     my $jobid = $1;
783 :     my $rest = $2;
784 :     my($uptime, $job, $user, $status, $date, $time, $slots) = split(/\s+/, $rest);
785 :     # print "Got job=$jobid status=$status user=$user date=$date time=$time finished=$finished\n";
786 :     $status = "done" if $finished;
787 :     my $ent = { id => $jobid, status => $status, user => $user, date => $date, time => $time, name => $job };
788 :    
789 :     $ent->{queue} = $queue if $queue;
790 :     $ent->{host} = $host if $host;
791 :    
792 :     $qstat->{$jobid} = $ent;
793 :    
794 :    
795 :     }
796 :     }
797 :     return $qstat;
798 :     }
799 :    
800 :     #
801 :     # Process the sim calculation.
802 :     #
803 :     # Invoke rp_chunk_sims to create the input job
804 :     # Queue a task-array job of rp_compute_sims.
805 :     # Queue a job rp_postproc_sims that is held on the taskarray job. This does
806 :     # the post-computation concatenation of the generated sims data when the sims
807 :     # have completed.
808 :     #
809 :     sub process_sims
810 :     {
811 :     my($genome, $job, $job_dir, $meta) = @_;
812 :    
813 :     if ($meta->get_metadata("sims.running") eq 'yes')
814 :     {
815 :     #
816 :     # We're already running. we might should check for dead SGE jobs,
817 :     # but I am going to skip that for now.
818 :     #
819 :     return;
820 :     }
821 :     my $cmd = "$FIG_Config::bin/rp_chunk_sims $job_dir/rp/$genome/Features/peg/fasta " .
822 :     "$sims_nr $sims_peg_synonyms $job_dir/sims.job";
823 :    
824 :    
825 :     #
826 :     # Create chunked input.
827 :     #
828 :    
829 :     $meta->add_log_entry($0, ["chunk", $cmd]);
830 :     if (!open(CHUNK, "$cmd |"))
831 :     {
832 :     warn "$cmd failed: $!\n";
833 :     $meta->add_log_entry($0, ["chunk_failed", $!]);
834 :     $meta->set_metadata("sims.running", "no");
835 :     $meta->set_metadata("status.sims", "error");
836 :     return;
837 :     }
838 :    
839 :     #
840 :     # Extract created task ids
841 :     #
842 :    
843 :     my($task_start, $task_end);
844 :     while (<CHUNK>)
845 :     {
846 :     print;
847 :     chomp;
848 :     if (/^tasks\s+(\d+)\s+(\d+)/)
849 :     {
850 :     $task_start = $1;
851 :     $task_end = $2;
852 :     }
853 :     }
854 :     close(CHUNK);
855 :    
856 :     if (!defined($task_start))
857 :     {
858 :     warn "$cmd did not return a task";
859 :     $meta->add_log_entry($0, "chunk_no_task");
860 :     $meta->set_metadata("sims.running", "no");
861 :     $meta->set_metadata("status.sims", "error");
862 :     return;
863 :     }
864 :    
865 :     #
866 :     # Submit.
867 :     #
868 :    
869 :     my $sge_job_id;
870 :    
871 :     eval {
872 :     $sge_job_id = sge_submit($meta,
873 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
874 :     "-N rp_s_$job -v PATH -b yes -t $task_start-$task_end",
875 :     "$FIG_Config::bin/rp_compute_sims $job_dir");
876 :     };
877 :     if ($@)
878 :     {
879 :     $meta->set_metadata("sims.running", "no");
880 :     $meta->set_metadata("status.sims", "error");
881 :     $meta->add_log_entry($0, ["sge submit failed", $@]);
882 :     warn "submit failed: $@\n";
883 :     return;
884 :     }
885 :    
886 :     #
887 :     # Also submit the postprocessing job, held on the sims run.
888 :     #
889 :    
890 :     my $pp_sge_id;
891 :     eval {
892 :    
893 :     $pp_sge_id = sge_submit($meta,
894 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
895 :     "-N rp_ps_$job -v PATH -b yes -hold_jid $sge_job_id -l fig_resource",
896 :     "$FIG_Config::bin/rp_postproc_sims $job_dir $sims_nr $sims_peg_synonyms $sims_keep_count");
897 :     };
898 :    
899 :     if ($@)
900 :     {
901 :     $meta->set_metadata("sims.running", "no");
902 :     $meta->set_metadata("status.sims", "error");
903 :     $meta->add_log_entry($0, ["sge postprocess submit failed", $@]);
904 :     warn "submit failed: $@\n";
905 :     system("qdel", $sge_job_id);
906 :     return;
907 :     }
908 :    
909 :     $meta->set_metadata("sims.running", "yes");
910 :     $meta->set_metadata("status.sims", "queued");
911 :    
912 :     $meta->set_metadata("sims.sge_job_id", $sge_job_id);
913 :     $meta->set_metadata("sims.sge_postproc_job_id", $pp_sge_id);
914 :     $meta->add_log_entry($0, ["submitted sims job", $sge_job_id]);
915 :     $meta->add_log_entry($0, ["submitted postprocess job", $pp_sge_id]);
916 :     Trace("Submitted, job id is $sge_job_id") if T(1);
917 :     }
918 :    
919 :     sub process_bbhs
920 :     {
921 :     my($genome, $job, $job_dir, $meta) = @_;
922 :    
923 :     if ($meta->get_metadata("bbhs.running") eq 'yes')
924 :     {
925 :     #
926 :     # We're already running. we might should check for dead SGE jobs,
927 :     # but I am going to skip that for now.
928 :     #
929 :     return;
930 :     }
931 :    
932 :     #
933 :     # Submit.
934 :     #
935 :    
936 :     my $sge_job_id;
937 :    
938 :     eval {
939 :     $sge_job_id = sge_submit($meta,
940 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
941 :     "-N rp_bbh_$job -v PATH -b yes -l fig_resource",
942 :     "$FIG_Config::bin/rp_compute_bbhs $job_dir");
943 :     };
944 :     if ($@)
945 :     {
946 :     $meta->set_metadata("bbhs.running", "no");
947 :     $meta->set_metadata("status.bbhs", "error");
948 :     $meta->add_log_entry($0, ["bbhs sge submit failed", $@]);
949 :     warn "submit failed: $@\n";
950 :     return;
951 :     }
952 :    
953 :     $meta->set_metadata("bbhs.running", "yes");
954 :     $meta->set_metadata("status.bbhs", "queued");
955 :    
956 :     $meta->set_metadata("bbhs.sge_job_id", $sge_job_id);
957 :     $meta->add_log_entry($0, ["submitted bbhs job", $sge_job_id]);
958 :     Trace("Submitted, job id is $sge_job_id") if T(1);
959 :     }
960 :    
961 :     sub process_auto_assign
962 :     {
963 :     my($genome, $job, $job_dir, $meta) = @_;
964 :    
965 :     if ($meta->get_metadata("auto_assign.running") eq 'yes')
966 :     {
967 :     #
968 :     # We're already running. we might should check for dead SGE jobs,
969 :     # but I am going to skip that for now.
970 :     #
971 :     return;
972 :     }
973 :    
974 :     #
975 :     # Submit.
976 :     #
977 :    
978 :     my $sge_job_id;
979 :    
980 :     eval {
981 :     $sge_job_id = sge_submit($meta,
982 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
983 :     "-N rp_aa_$job -v PATH -b yes -l fig_resource",
984 :     "$FIG_Config::bin/rp_auto_assign $job_dir");
985 :     };
986 :     if ($@)
987 :     {
988 :     $meta->set_metadata("auto_assign.running", "no");
989 :     $meta->set_metadata("status.auto_assign", "error");
990 :     $meta->add_log_entry($0, ["auto_assign sge submit failed", $@]);
991 :     warn "submit failed: $@\n";
992 :     return;
993 :     }
994 :    
995 :     $meta->set_metadata("auto_assign.running", "yes");
996 :     $meta->set_metadata("status.auto_assign", "queued");
997 :    
998 :     $meta->set_metadata("auto_assign.sge_job_id", $sge_job_id);
999 :     $meta->add_log_entry($0, ["submitted auto_assign job", $sge_job_id]);
1000 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1001 :     }
1002 :    
1003 :     sub process_glue_contigs
1004 :     {
1005 :     my($genome, $job, $job_dir, $meta) = @_;
1006 :    
1007 :     if ($meta->get_metadata("glue_contigs.running") eq 'yes')
1008 :     {
1009 :     #
1010 :     # We're already running. we might should check for dead SGE jobs,
1011 :     # but I am going to skip that for now.
1012 :     #
1013 :     return;
1014 :     }
1015 :    
1016 :     #
1017 :     # Submit.
1018 :     #
1019 :    
1020 :     my $sge_job_id;
1021 :    
1022 :     eval {
1023 :     $sge_job_id = sge_submit($meta,
1024 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1025 :     "-N rp_glue_$job -v PATH -b yes -l fig_resource",
1026 :     "$FIG_Config::bin/rp_glue_contigs $job_dir");
1027 :     };
1028 :     if ($@)
1029 :     {
1030 :     $meta->set_metadata("glue_contigs.running", "no");
1031 :     $meta->set_metadata("status.glue_contigs", "error");
1032 :     $meta->add_log_entry($0, ["glue_contigs sge submit failed", $@]);
1033 :     warn "submit failed: $@\n";
1034 :     return;
1035 :     }
1036 :    
1037 :     $meta->set_metadata("glue_contigs.running", "yes");
1038 :     $meta->set_metadata("status.glue_contigs", "queued");
1039 :    
1040 :     $meta->set_metadata("glue_contigs.sge_job_id", $sge_job_id);
1041 :     $meta->add_log_entry($0, ["submitted glue_contigs job", $sge_job_id]);
1042 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1043 :     }
1044 :    
1045 :     sub process_pchs
1046 :     {
1047 :     my($genome, $job, $job_dir, $meta) = @_;
1048 :    
1049 :     if ($meta->get_metadata("pchs.running") eq 'yes')
1050 :     {
1051 :     #
1052 :     # We're already running. we might should check for dead SGE jobs,
1053 :     # but I am going to skip that for now.
1054 :     #
1055 :     return;
1056 :     }
1057 :    
1058 :     #
1059 :     # Submit.
1060 :     #
1061 :    
1062 :     my $sge_job_id;
1063 :    
1064 :     eval {
1065 :     $sge_job_id = sge_submit($meta,
1066 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1067 :     "-N rp_pch_$job -v PATH -b yes -l fig_resource",
1068 :     "$FIG_Config::bin/rp_compute_pchs $job_dir");
1069 :     };
1070 :     if ($@)
1071 :     {
1072 :     $meta->set_metadata("pchs.running", "no");
1073 :     $meta->set_metadata("status.pchs", "error");
1074 :     $meta->add_log_entry($0, ["pchs sge submit failed", $@]);
1075 :     warn "submit failed: $@\n";
1076 :     return;
1077 :     }
1078 :    
1079 :     $meta->set_metadata("pchs.running", "yes");
1080 :     $meta->set_metadata("status.pchs", "queued");
1081 :    
1082 :     $meta->set_metadata("pchs.sge_job_id", $sge_job_id);
1083 :     $meta->add_log_entry($0, ["submitted pchs job", $sge_job_id]);
1084 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1085 :     }
1086 :    
1087 :     sub process_scenario
1088 :     {
1089 :     my($genome, $job, $job_dir, $meta) = @_;
1090 :    
1091 :     if ($meta->get_metadata("scenario.running") eq 'yes')
1092 :     {
1093 :     #
1094 :     # We're already running. we might should check for dead SGE jobs,
1095 :     # but I am going to skip that for now.
1096 :     #
1097 :     return;
1098 :     }
1099 :    
1100 :     #
1101 :     # Submit.
1102 :     #
1103 :    
1104 :     my $sge_job_id;
1105 :    
1106 :     eval {
1107 :     $sge_job_id = sge_submit($meta,
1108 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1109 :     "-N rp_sc_$job -v PATH -b yes -l fig_resource",
1110 :     "$FIG_Config::bin/rp_scenarios $job_dir");
1111 :     };
1112 :     if ($@)
1113 :     {
1114 :     $meta->set_metadata("scenario.running", "no");
1115 :     $meta->set_metadata("status.scenario", "error");
1116 :     $meta->add_log_entry($0, ["scenario sge submit failed", $@]);
1117 :     warn "submit failed: $@\n";
1118 :     return;
1119 :     }
1120 :    
1121 :     $meta->set_metadata("scenario.running", "yes");
1122 :     $meta->set_metadata("status.scenario", "queued");
1123 :    
1124 :     $meta->set_metadata("scenario.sge_job_id", $sge_job_id);
1125 :     $meta->add_log_entry($0, ["submitted scenario job", $sge_job_id]);
1126 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1127 :     }
1128 :    
1129 :     sub process_glimmer
1130 :     {
1131 :     my($genome, $job, $job_dir, $meta) = @_;
1132 :    
1133 :     if ($meta->get_metadata("glimmer.running") eq 'yes')
1134 :     {
1135 :     #
1136 :     # We're already running. we might should check for dead SGE jobs,
1137 :     # but I am going to skip that for now.
1138 :     #
1139 :     return;
1140 :     }
1141 :    
1142 :     #
1143 :     # Submit.
1144 :     #
1145 :    
1146 :     my $sge_job_id;
1147 :    
1148 :     eval {
1149 :     $sge_job_id = sge_submit($meta,
1150 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1151 :     "-N rp_gl_$job -v PATH -b yes -l fig_resource",
1152 :     "$FIG_Config::bin/rp_glimmer $job_dir");
1153 :     };
1154 :     if ($@)
1155 :     {
1156 :     $meta->set_metadata("glimmer.running", "no");
1157 :     $meta->set_metadata("status.glimmer", "error");
1158 :     $meta->add_log_entry($0, ["glimmer sge submit failed", $@]);
1159 :     warn "submit failed: $@\n";
1160 :     return;
1161 :     }
1162 :    
1163 :     $meta->set_metadata("glimmer.running", "yes");
1164 :     $meta->set_metadata("status.glimmer", "queued");
1165 :    
1166 :     $meta->set_metadata("glimmer.sge_job_id", $sge_job_id);
1167 :     $meta->add_log_entry($0, ["submitted glimmer job", $sge_job_id]);
1168 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1169 :     }
1170 :    
1171 :     sub process_critica
1172 :     {
1173 :     my($genome, $job, $job_dir, $meta) = @_;
1174 :    
1175 :     if ($meta->get_metadata("critica.running") eq 'yes')
1176 :     {
1177 :     #
1178 :     # We're already running. we might should check for dead SGE jobs,
1179 :     # but I am going to skip that for now.
1180 :     #
1181 :     return;
1182 :     }
1183 :    
1184 :     #
1185 :     # Submit.
1186 :     #
1187 :    
1188 :     my $sge_job_id;
1189 :    
1190 :     eval {
1191 :     $sge_job_id = sge_submit($meta,
1192 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1193 :     "-N rp_cr_$job -v PATH -b yes -l fig_resource",
1194 :     "$FIG_Config::bin/rp_critica $job_dir");
1195 :     };
1196 :     if ($@)
1197 :     {
1198 :     $meta->set_metadata("critica.running", "no");
1199 :     $meta->set_metadata("status.critica", "error");
1200 :     $meta->add_log_entry($0, ["critica sge submit failed", $@]);
1201 :     warn "submit failed: $@\n";
1202 :     return;
1203 :     }
1204 :    
1205 :     $meta->set_metadata("critica.running", "yes");
1206 :     $meta->set_metadata("status.critica", "queued");
1207 :    
1208 :     $meta->set_metadata("critica.sge_job_id", $sge_job_id);
1209 :     $meta->add_log_entry($0, ["submitted critica job", $sge_job_id]);
1210 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1211 :     }
1212 :    
1213 :     sub process_pfam
1214 :     {
1215 :     my($genome, $job, $job_dir, $meta) = @_;
1216 :    
1217 :     if ($meta->get_metadata("pfam.running") eq 'yes')
1218 :     {
1219 :     #
1220 :     # We're already running. we might should check for dead SGE jobs,
1221 :     # but I am going to skip that for now.
1222 :     #
1223 :     return;
1224 :     }
1225 :    
1226 :     #
1227 :     # Submit.
1228 :     #
1229 :    
1230 :     my $sge_job_id;
1231 :    
1232 :     eval {
1233 :     $sge_job_id = sge_submit($meta,
1234 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1235 :     "-N rp_pf_$job -v PATH -b yes -l fig_resource",
1236 :     "$FIG_Config::bin/rp_PFAM_attribute_generation $job_dir");
1237 :     };
1238 :     if ($@)
1239 :     {
1240 :     $meta->set_metadata("pfam.running", "no");
1241 :     $meta->set_metadata("status.pfam", "error");
1242 :     $meta->add_log_entry($0, ["pfam sge submit failed", $@]);
1243 :     warn "submit failed: $@\n";
1244 :     return;
1245 :     }
1246 :    
1247 :     $meta->set_metadata("pfam.running", "yes");
1248 :     $meta->set_metadata("status.pfam", "queued");
1249 :    
1250 :     $meta->set_metadata("pfam.sge_job_id", $sge_job_id);
1251 :     $meta->add_log_entry($0, ["submitted pfam job", $sge_job_id]);
1252 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1253 :     }
1254 :    
1255 :     =head2 process_rp
1256 :    
1257 :     Start or check status on the rapid propagation.
1258 :    
1259 :     =cut
1260 :    
1261 :     sub process_rp
1262 :     {
1263 :     my($genome, $job, $job_dir, $meta) = @_;
1264 :    
1265 :     if ($meta->get_metadata("rp.running") eq 'yes')
1266 :     {
1267 :     #
1268 :     # We're already running. we might should check for dead SGE jobs,
1269 :     # but I am going to skip that for now.
1270 :     #
1271 :     return;
1272 :     }
1273 :    
1274 :     #
1275 :     # Submit.
1276 :     #
1277 :    
1278 :     my $sge_job_id;
1279 :    
1280 :     eval {
1281 :     $sge_job_id = sge_submit($meta,
1282 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1283 :     "-N rp_$job -v PATH -b yes -l fig_resource",
1284 :     "$FIG_Config::bin/rp_rapid_propagation $job_dir");
1285 :     };
1286 :     if ($@)
1287 :     {
1288 :     $meta->set_metadata("rp.running", "no");
1289 :     $meta->set_metadata("status.rp", "error");
1290 :     $meta->add_log_entry($0, ["rp sge submit failed", $@]);
1291 :     warn "submit failed: $@\n";
1292 :     return;
1293 :     }
1294 :    
1295 :     $meta->set_metadata("rp.running", "yes");
1296 :     $meta->set_metadata("status.rp", "queued");
1297 :    
1298 :     $meta->set_metadata("rp.sge_job_id", $sge_job_id);
1299 :     $meta->add_log_entry($0, ["submitted rp job", $sge_job_id]);
1300 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1301 :     }
1302 :    
1303 :     #
1304 :     # Determine if we can set the stoplight value to complete. This is the case
1305 :     # if qc.embedded and qc.RNA_overlaps are both zero.
1306 :     #
1307 :     # If we don't automatically set the stoplight to complete, and we
1308 :     # haven't done so yet, send notification email to the user.
1309 :     #
1310 :     sub check_qc_status_for_intervention
1311 :     {
1312 :     my($genome, $job_id, $job_dir, $meta) = @_;
1313 :    
1314 :     my $val = $meta->get_metadata('qc.Embedded');
1315 :     my $num_embed = $val ? $val->[1] : 0;
1316 :    
1317 :     $val = $meta->get_metadata('qc.RNA_overlaps');
1318 :     my $num_overlaps = $val ? $val->[1] : 0;
1319 :    
1320 :     if ($num_embed == 0 && $num_overlaps == 0)
1321 :     {
1322 :     $meta->set_metadata("stoplight.acceptedby", "pipeline_automatic");
1323 :     $meta->set_metadata("stoplight.timestamp", time);
1324 :     $meta->set_metadata("status.stoplight", "complete");
1325 :     print "Automatically accepting quality on $job_id $genome\n";
1326 :     return;
1327 :     }
1328 :    
1329 :     if ($meta->get_metadata("qc.email_notification_sent") ne "yes")
1330 :     {
1331 :     my $job = new Job48($job_id);
1332 :     my $userobj = $job->getUserObject();
1333 :    
1334 :     if ($userobj)
1335 :     {
1336 :     my $email = $userobj->eMail();
1337 :     my $name = join(" " , $userobj->firstName(), $userobj->lastName());
1338 :    
1339 :     my $full = $name ? "$name <$email>" : $email;
1340 :     print "send notification email to $full\n";
1341 :    
1342 :     my $mail = Mail::Mailer->new();
1343 :     $mail->open({
1344 :     To => $full,
1345 :     From => 'Annotation Server <rast@mcs.anl.gov>',
1346 :     Subject => "RAST annotation server job needs attention"
1347 :     });
1348 :    
1349 :     my $gname = $job->genome_name;
1350 :     my $entry = $FIG_Config::fortyeight_home;
1351 :     $entry = "http://www.nmpdr.org/anno-server/" if $entry eq '';
1352 :     print $mail "The annotation job that you submitted for $gname needs user input before it can proceed further.\n";
1353 :     print $mail "You may query its status at $entry as job number $job_id.\n";
1354 :     $mail->close();
1355 :     $meta->set_metadata("qc.email_notification_sent", "yes");
1356 :     $meta->set_metadata("qc.email_notification_sent_address", $email);
1357 :     }
1358 :     }
1359 :     }
1360 :     sub process_qc
1361 :     {
1362 :     my($genome, $job, $job_dir, $meta) = @_;
1363 :    
1364 :     if ($meta->get_metadata("qc.running") eq 'yes')
1365 :     {
1366 :     #
1367 :     # We're already running. we might should check for dead SGE jobs,
1368 :     # but I am going to skip that for now.
1369 :     #
1370 :     return;
1371 :     }
1372 :    
1373 :     #
1374 :     # Submit.
1375 :     #
1376 :    
1377 :     my $sge_job_id;
1378 :    
1379 :     eval {
1380 :     $sge_job_id = sge_submit($meta,
1381 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1382 :     "-N rp_qc_$job -v PATH -b yes -l fig_resource",
1383 :     "$FIG_Config::bin/rp_quality_check $job_dir");
1384 :     };
1385 :     if ($@)
1386 :     {
1387 :     $meta->set_metadata("qc.running", "no");
1388 :     $meta->set_metadata("status.qc", "error");
1389 :     $meta->add_log_entry($0, ["qc sge submit failed", $@]);
1390 :     warn "submit failed: $@\n";
1391 :     return;
1392 :     }
1393 :    
1394 :     $meta->set_metadata("qc.running", "yes");
1395 :     $meta->set_metadata("status.qc", "queued");
1396 :    
1397 :     $meta->set_metadata("qc.sge_job_id", $sge_job_id);
1398 :     $meta->add_log_entry($0, ["submitted qc job", $sge_job_id]);
1399 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1400 :     }
1401 :    
1402 :     sub process_correction
1403 :     {
1404 :     my($genome, $job, $job_dir, $meta, $req) = @_;
1405 :    
1406 :     my $sge_job_id;
1407 :    
1408 :     if ($meta->get_metadata("correction.running") eq 'yes')
1409 :     {
1410 :     #
1411 :     # We're already running. we might should check for dead SGE jobs,
1412 :     # but I am going to skip that for now.
1413 :     #
1414 :     return;
1415 :     }
1416 :    
1417 :     my $req_str = join(",", @$req);
1418 :    
1419 :     eval {
1420 :     $sge_job_id = sge_submit($meta,
1421 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1422 :     "-N rp_cor_$job -v PATH -b yes -l fig_resource",
1423 :     "$FIG_Config::bin/rp_correction $job_dir '$req_str'");
1424 :     };
1425 :     if ($@)
1426 :     {
1427 :     $meta->set_metadata("correction.running", "no");
1428 :     $meta->set_metadata("status.correction", "error");
1429 :     $meta->add_log_entry($0, ["correction sge submit failed", $@]);
1430 :     warn "submit failed: $@\n";
1431 :     return;
1432 :     }
1433 :    
1434 :     $meta->set_metadata("correction.running", "yes");
1435 :     $meta->set_metadata("status.correction", "queued");
1436 :    
1437 :     $meta->set_metadata("correction.sge_job_id", $sge_job_id);
1438 :     $meta->add_log_entry($0, ["submitted correction job", $sge_job_id]);
1439 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1440 :     }
1441 :    
1442 :     #
1443 :     # Mark the job as complete as far as the user is concerned.
1444 :     #
1445 :     # It is still active in the pipeline until it either is processed for
1446 :     # SEED inclusion, or marked to not be included.
1447 :     #
1448 :     sub mark_job_user_complete
1449 :     {
1450 :     my($genome, $job_id, $job_dir, $meta, $req) = @_;
1451 :    
1452 :     my $job = new Job48($job_id);
1453 :    
1454 :     my $userobj = $job->getUserObject();
1455 :    
1456 :     if ($userobj)
1457 :     {
1458 :     my $email = $userobj->eMail();
1459 :     my $name = join(" " , $userobj->firstName(), $userobj->lastName());
1460 :    
1461 :     my $full = $name ? "$name <$email>" : $email;
1462 :     print "send email to $full\n";
1463 :    
1464 :     my $mail = Mail::Mailer->new();
1465 :     $mail->open({
1466 :     To => $full,
1467 :     From => 'Annotation Server <rast@mcs.anl.gov>',
1468 :     Subject => "RAST annotation server job completed"
1469 :     });
1470 :    
1471 :     my $gname = $job->genome_name;
1472 :     my $entry = $FIG_Config::fortyeight_home;
1473 :     $entry = "http://www.nmpdr.org/anno-server/" if $entry eq '';
1474 :     print $mail "The annotation job that you submitted for $gname has completed.\n";
1475 :     print $mail "It is available for browsing at $entry as job number $job_id.\n";
1476 :     $mail->close();
1477 :     }
1478 :    
1479 :     $meta->set_metadata("status.final", "complete");
1480 :    
1481 :     #
1482 :     # If the job is a SEED candidate, send VV email.
1483 :     #
1484 :    
1485 :     if ($meta->get_metadata("submit.suggested") or
1486 :     $meta->get_metadata("submit.candidate"))
1487 :     {
1488 :     my $gname = $job->genome_name;
1489 :     my $mail = Mail::Mailer->new();
1490 :     $mail->open({
1491 :     To => 'Veronika Vonstein <veronika@thefig.info>, Robert Olson<olson@mcs.anl.gov>',
1492 :     From => 'Annotation Server <rast@mcs.anl.gov>',
1493 :     Subject => "RAST job $job_id marked for SEED inclusion",
1494 :     });
1495 :    
1496 :     print $mail <<END;
1497 :     RAST job #$job_id ($gname) was submitted for inclusion into the SEED, and has finished its processing.
1498 :     END
1499 :     $mail->close();
1500 :     }
1501 :     }
1502 :    
1503 :     #
1504 :     # Mark the job as utterly done.
1505 :     #
1506 :     sub mark_job_done
1507 :     {
1508 :     my($genome, $job_id, $job_dir, $meta, $req) = @_;
1509 :    
1510 :     if (open(D, ">$job_dir/DONE"))
1511 :     {
1512 :     print D time . "\n";
1513 :     close(D);
1514 :     }
1515 :     else
1516 :     {
1517 :     warn "Error opening $job_dir/DONE: $!\n";
1518 :     }
1519 :    
1520 :     unlink("$job_dir/ACTIVE");
1521 :     }
1522 :    
1523 :     sub sge_submit
1524 :     {
1525 :     my($meta, $sge_args, $cmd) = @_;
1526 :    
1527 :     my $sge_cmd = "qsub $sge_args $cmd";
1528 :    
1529 :     $meta->add_log_entry($0, $sge_cmd);
1530 :    
1531 :     if (!open(Q, "$sge_cmd 2>&1 |"))
1532 :     {
1533 :     die "Qsub failed: $!";
1534 :     }
1535 :     my $sge_job_id;
1536 :     my $submit_output;
1537 :     while (<Q>)
1538 :     {
1539 :     $submit_output .= $_;
1540 :     print "Qsub: $_";
1541 :     if (/Your\s+job\s+(\d+)/)
1542 :     {
1543 :     $sge_job_id = $1;
1544 :     }
1545 :     elsif (/Your\s+job-array\s+(\d+)/)
1546 :     {
1547 :     $sge_job_id = $1;
1548 :     }
1549 :     }
1550 :     $meta->add_log_entry($0, ["qsub_output", $submit_output]);
1551 :     if (!close(Q))
1552 :     {
1553 :     die "Qsub close failed: $!";
1554 :     }
1555 :    
1556 :     if (!$sge_job_id)
1557 :     {
1558 :     die "did not get job id from qsub";
1559 :     }
1560 :    
1561 :     return $sge_job_id;
1562 :     }
1563 :    
1564 :     sub process_cello
1565 :     {
1566 :     my($genome, $job, $job_dir, $meta) = @_;
1567 :    
1568 :     if ($meta->get_metadata("cello.running") eq 'yes')
1569 :     {
1570 :     #
1571 :     # We're already running. we might should check for dead SGE jobs,
1572 :     # but I am going to skip that for now.
1573 :     #
1574 :     return;
1575 :     }
1576 :    
1577 :     #
1578 :     # Submit.
1579 :     #
1580 :    
1581 :     my $sge_job_id;
1582 :    
1583 :     eval {
1584 :     $sge_job_id = sge_submit($meta,
1585 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1586 :     "-N rp_cl_$job -v PATH -b yes",
1587 :     "$FIG_Config::bin/rp_CELLO_attribute_generation $job_dir");
1588 :     };
1589 :     if ($@)
1590 :     {
1591 :     $meta->set_metadata("cello.running", "no");
1592 :     $meta->set_metadata("status.cello", "error");
1593 :     $meta->add_log_entry($0, ["cello sge submit failed", $@]);
1594 :     warn "submit failed: $@\n";
1595 :     return;
1596 :     }
1597 :    
1598 :     $meta->set_metadata("cello.running", "yes");
1599 :     $meta->set_metadata("status.cello", "queued");
1600 :    
1601 :     $meta->set_metadata("cello.sge_job_id", $sge_job_id);
1602 :     $meta->add_log_entry($0, ["submitted cello job", $sge_job_id]);
1603 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1604 :     }
1605 :    
1606 :     sub process_phobius
1607 :     {
1608 :     my($genome, $job, $job_dir, $meta) = @_;
1609 :    
1610 :     if ($meta->get_metadata("phobius.running") eq 'yes')
1611 :     {
1612 :     #
1613 :     # We're already running. we might should check for dead SGE jobs,
1614 :     # but I am going to skip that for now.
1615 :     #
1616 :     return;
1617 :     }
1618 :    
1619 :     #
1620 :     # Submit.
1621 :     #
1622 :    
1623 :     my $sge_job_id;
1624 :    
1625 :     eval {
1626 :     $sge_job_id = sge_submit($meta,
1627 :     "-e $job_dir/sge_output -o $job_dir/sge_output " .
1628 :     "-N rp_ph_$job -v PATH -b yes",
1629 :     "$FIG_Config::bin/rp_PHOBIUS_attribute_generation $job_dir");
1630 :     };
1631 :     if ($@)
1632 :     {
1633 :     $meta->set_metadata("phobius.running", "no");
1634 :     $meta->set_metadata("status.phobius", "error");
1635 :     $meta->add_log_entry($0, ["phobius sge submit failed", $@]);
1636 :     warn "submit failed: $@\n";
1637 :     return;
1638 :     }
1639 :    
1640 :     $meta->set_metadata("phobius.running", "yes");
1641 :     $meta->set_metadata("status.phobius", "queued");
1642 :    
1643 :     $meta->set_metadata("phobius.sge_job_id", $sge_job_id);
1644 :     $meta->add_log_entry($0, ["submitted phobius job", $sge_job_id]);
1645 :     Trace("Submitted, job id is $sge_job_id") if T(1);
1646 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3