[Bio] / FigKernelPackages / RAST_submission.pm Repository:
ViewVC logotype

Annotation of /FigKernelPackages/RAST_submission.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : olson 1.1
2 :     package RAST_submission;
3 :    
4 : olson 1.4
5 : olson 1.1 use strict;
6 :     use Job48;
7 :     use JobUpload;
8 :     use Data::Dumper;
9 : olson 1.4 use FIG;
10 :     use FIG_Config;
11 :     use gjoseqlib;
12 : olson 1.7 use XML::LibXML;
13 : olson 1.4
14 :     use LWP::UserAgent;
15 :     use Bio::DB::RefSeq;
16 :     use Bio::SeqIO;
17 : olson 1.1
18 :     use base 'Class::Accessor';
19 :    
20 : olson 1.4 __PACKAGE__->mk_accessors(qw(rast_dbmaster user_dbmaster user_obj project_cache_dir
21 :     contig_cache_dir max_cache_age ua));
22 : olson 1.1
23 :     sub new
24 :     {
25 :     my($class, $rast_dbmaster, $user_dbmaster, $user_obj) = @_;
26 :    
27 :     my $self = {
28 :     rast_dbmaster => $rast_dbmaster,
29 :     user_dbmaster => $user_dbmaster,
30 :     user_obj => $user_obj,
31 : olson 1.4 project_cache_dir => "$FIG_Config::var/ncbi_project_cache",
32 :     contig_cache_dir => "$FIG_Config::var/ncbi_contig_cache",
33 :     max_cache_age => 86400,
34 :     ua => LWP::UserAgent->new(),
35 : olson 1.1 };
36 :    
37 : olson 1.4 &FIG::verify_dir($self->{project_cache_dir});
38 :     &FIG::verify_dir($self->{contig_cache_dir});
39 :    
40 : olson 1.1
41 :     return bless $self, $class;
42 :     }
43 :    
44 : olson 1.4 sub get_contig_ids_in_project_from_entrez
45 :     {
46 :     my($self, $params) = @_;
47 :    
48 :     #
49 :     # Determine the project ID to use. Which one we take depends on if
50 :     # we were passed a project id, a tax id, or a contig id.
51 :     #
52 :    
53 :     my $proj;
54 :     if ($params->{-tax_id})
55 :     {
56 :     }
57 :     elsif ($params->{-contig_id})
58 :     {
59 :     $proj = $self->determine_project_of_contig($params->{-contig_id});
60 :     }
61 :     elsif ($params->{-project_id})
62 :     {
63 :     $proj = $params->{-project_id};
64 :     }
65 :    
66 :     print STDERR "project is $proj\n";
67 :     my $project_data = $self->retrieve_project_data($proj);
68 :    
69 :     return $self->check_project_for_redundancy($project_data);
70 :     }
71 :    
72 : olson 1.5 sub get_contigs_from_entrez
73 :     {
74 :     my($self, $params) = @_;
75 :    
76 :     my $id_list = $params->{-id};
77 :     if (!ref($id_list))
78 :     {
79 :     $id_list = [$id_list];
80 :     }
81 :    
82 :     my @ret;
83 :     for my $id (@$id_list)
84 :     {
85 : olson 1.6 my $ent = { id => $id };
86 :    
87 : olson 1.5 my $file = $self->retrieve_contig_data($id);
88 : olson 1.6
89 : olson 1.5 open(F, "<", $file);
90 : olson 1.6 my $txt = <F>;
91 :     if ($txt =~ /^LOCUS.*?(\d+)\s+bp/)
92 :     {
93 :     $ent->{length} = $1;
94 :     }
95 :    
96 :     while (<F>)
97 :     {
98 :     $txt .= $_;
99 :     if (/^\s+ORGANISM\s+(.*)/)
100 :     {
101 :     $ent->{name} = $1;
102 :     }
103 :     elsif (/^DBLINK\s+Project:(\d+)/)
104 :     {
105 :     $ent->{project} = $1;
106 :     }
107 :     elsif (/db_xref="taxon:(\d+)"/)
108 :     {
109 :     $ent->{taxonomy_id} = $1;
110 :     }
111 :     }
112 :     $ent->{contents} = $txt;
113 : olson 1.5
114 :     close(F);
115 : olson 1.6
116 : olson 1.7 if ($ent->{taxonomy_id})
117 :     {
118 :     #
119 :     # Pull the taxonomy database entry from NCBI.
120 :     #
121 :    
122 :     my $tdata = $self->get_taxonomy_data($ent->{taxonomy_id});
123 :     if ($tdata)
124 :     {
125 :     $ent->{domain} = $tdata->{domain};
126 :     $ent->{taxonomy} = $tdata->{taxonomy};
127 :     $ent->{genetic_code} = $tdata->{genetic_code};
128 :     }
129 :     }
130 :    
131 : olson 1.6 push(@ret, $ent);
132 : olson 1.5 }
133 :    
134 : olson 1.7
135 : olson 1.5 return \@ret;
136 :     }
137 :    
138 : olson 1.7 sub get_taxonomy_data
139 :     {
140 :     my($self, $tax_id) = @_;
141 :    
142 :     my $res = $self->ua->get("http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=taxonomy&id=$tax_id&report=sgml&mode=text");
143 :     if ($res->is_success)
144 :     {
145 :     my $ent = {};
146 :     my $doc = XML::LibXML->new->parse_string($res->content);
147 :    
148 :     my $lin = $doc->findvalue('//Taxon/Lineage');
149 :     $lin =~ s/^cellular organisms;\s+//;
150 :     my $domain = $lin;
151 :     $domain =~ s/;.*$//;
152 :     my $code = $doc->findvalue('//Taxon/GeneticCode/GCId');
153 :    
154 :     $ent->{domain} = $domain;
155 :     $ent->{taxonomy} = $lin;
156 :     $ent->{genetic_code} = $code;
157 :     return $ent;
158 :     }
159 :     return undef;
160 :     }
161 :    
162 : olson 1.4 sub determine_project_of_contig
163 :     {
164 :     my($self, $contig_id) = @_;
165 :    
166 :     my $file = $self->retrieve_contig_data($contig_id);
167 :     open(F, "<", $file) or die "cannot open contig data $file: $!";
168 :    
169 :     my $proj;
170 :     while (<F>)
171 :     {
172 :     if (/DBLINK\s+Project:(\d+)/)
173 :     {
174 :     $proj = $1;
175 :     last;
176 :     }
177 :     }
178 :     close(F);
179 :     return $proj;
180 :    
181 :     }
182 :    
183 :     sub check_project_for_redundancy
184 :     {
185 :     my($self, $file) = @_;
186 :    
187 :     my $seqio_object = Bio::SeqIO->new(
188 :     -file => $file ,
189 :     -format => "genbank",
190 :     );
191 :    
192 :     my @seqs;
193 :     my @ids;
194 :     while ( my $seq = $seqio_object->next_seq ) {
195 :     push(@seqs, [$seq->accession_number, $seq->seq]);
196 :     push(@ids, $seq->accession_number);
197 :     }
198 :    
199 :     my @redundancy = $self->test_for_redundancy(\@seqs);
200 :     return { ids => \@ids, redundancy_report => \@redundancy };
201 :     }
202 :    
203 :     sub test_for_redundancy {
204 :     my($self, $seqs) = @_;
205 :    
206 :     if (@$seqs < 2)
207 :     {
208 :     return ();
209 :     }
210 :    
211 :     my %lens = map { $_->[0] => length($_->[1]) } @$seqs;
212 :     my $tmp = "tmp.$$.fasta";
213 :     &gjoseqlib::print_alignment_as_fasta($tmp,$seqs);
214 :     system "formatdb -i $tmp -pF";
215 :     my @blastout = `blastall -m8 -i $tmp -d $tmp -p blastn -FF -e 1.0e-100`;
216 :     system "rm $tmp $tmp\.*";
217 :     my @tuples = ();
218 :     my %seen;
219 :     foreach my $hit (map { chomp; [split(/\t/,$_)] } @blastout)
220 :     {
221 :     my($id1,$id2,$iden,undef,undef,undef,$b1,$e1,$b2,$e2) = @$hit;
222 :     if ((! $seen{"$id1/$id2"}) && ($id1 ne $id2))
223 :     {
224 :     $seen{"$id1/$id2"} = 1;
225 :     if (($iden >= 98) &&
226 :     (abs($e1 - $b1) > (0.9 * $lens{$id1})))
227 :     {
228 :     push(@tuples,[$id1,$lens{$id1},$id2,$lens{$id2}]);
229 :     }
230 :     }
231 :     }
232 :    
233 :     return @tuples;
234 :     }
235 :    
236 :     sub retrieve_project_data
237 :     {
238 :     my($self, $project) = @_;
239 :    
240 :     my $cached_file = $self->project_cache_dir() . "/$project.gbff";
241 :     if (my(@stat) = stat($cached_file))
242 :     {
243 :     my $last_mod = $stat[9];
244 :     if (time - $last_mod < $self->max_cache_age)
245 :     {
246 :     return $cached_file;
247 :     }
248 :     }
249 :    
250 :     my $url = "http://www.ncbi.nlm.nih.gov/sites/entrez?Db=genomeprj&Cmd=Retrieve&list_uids=";
251 :     my $res = $self->ua->get($url.$project);
252 :     if (!$res->is_success)
253 :     {
254 :     die "error retrieving project data: " . $res->status_line;
255 :     }
256 :     my $search_result = $res->content;
257 :    
258 :     my @lines = split ( "\n" , $search_result);
259 :    
260 :     my $nr_seq = 0;
261 :     my $nr_proj = 0;
262 :     my $url_seq = "";
263 :     my $url_proj = "";
264 :     my $genome_name = "";
265 :    
266 :     my $found_genome_information_table = 0;
267 :    
268 :     my $next = "";
269 :     my $id_list = "";
270 :     foreach my $line ( @lines )
271 :     {
272 :    
273 :     if ($line =~/Genome information:/){
274 :     $found_genome_information_table = 1;
275 :     next; # skip table line
276 :     };
277 :    
278 :     $found_genome_information_table = 0 if ( $found_genome_information_table and $line =~ /<\/table>/);
279 :     $id_list .= $line if ( $found_genome_information_table ); # collect id entries
280 :    
281 :     # print $line , "\n" if ( $found_genome_information_table );
282 :     }
283 :    
284 :     my @ids;
285 :     my @blocks = split "<\/tr>" , $id_list ;
286 :     foreach my $block (@blocks)
287 :     {
288 :     my @local_ids = $block =~/([^>]+)<\/a><\/td>/gc ;
289 :     # print join "\t" , @local_ids , "\n";
290 :     push @ids , $local_ids[0] if ($local_ids[0]);
291 :     }
292 :    
293 :     my $id_list = join(",", @ids);
294 :     my $query = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nucleotide&id=" . $id_list . "&rettype=gb" ;
295 :     print STDERR $query , "\n";
296 :     my $resp = $self->ua->get($query);
297 :     if ($resp->is_success())
298 :     {
299 :     open(F, ">", $cached_file) or die "Cannot open $cached_file for writing: $!";
300 :     print F $resp->content;
301 :     close(F);
302 :     return $cached_file;
303 :     }
304 :     else
305 :     {
306 :     die "Error retrieving data: " . $resp->status_line;
307 :     }
308 :     }
309 :    
310 :     sub retrieve_contig_data
311 :     {
312 :     my($self, $contig) = @_;
313 :    
314 :     my $cached_file = $self->contig_cache_dir() . "/$contig.gbff";
315 :     if (my(@stat) = stat($cached_file))
316 :     {
317 :     my $last_mod = $stat[9];
318 :     if (time - $last_mod < $self->max_cache_age)
319 :     {
320 :     return $cached_file;
321 :     }
322 :     }
323 :    
324 :     my $query = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nucleotide&id=" . $contig . "&rettype=gb" ;
325 :     print STDERR $query , "\n";
326 :     my $resp = $self->ua->get($query);
327 :     if ($resp->is_success())
328 :     {
329 :     open(F, ">", $cached_file) or die "Cannot open $cached_file for writing: $!";
330 :     print F $resp->content;
331 :     close(F);
332 :     return $cached_file;
333 :     }
334 :     else
335 :     {
336 :     die "Error retrieving data: " . $resp->status_line;
337 :     }
338 :     }
339 :    
340 : olson 1.7 =head3 submit_RAST_job
341 :    
342 :     Handle the actual job submission.
343 :    
344 :     Use JobUpload.pm to create a clean input file (fixing line endings,
345 :     etc) and to pull stats for the job.
346 :    
347 :     Use Job48::create_new_job to then create the job from the
348 :     data we brought in.
349 :    
350 :     =cut
351 : olson 1.4
352 : olson 1.1 sub submit_RAST_job
353 :     {
354 :     my($self, $params) = @_;
355 :    
356 : olson 1.7 my $filetype = lc($params->{-filetype});
357 :     my $tax_id = $params->{-taxonomyID};
358 :     my $domain = lc($params->{-domain});
359 :     my $organism = $params->{-organismName};
360 :     my $file = $params->{-file};
361 :     my $keep = $params->{-keepGeneCalls};
362 :     my $genetic_code = $params->{-geneticCode};
363 :     my $gene_caller = lc($params->{-geneCaller});
364 :    
365 :     my $work_dir = "$FIG_Config::temp/rast_submit_tmp.$$";
366 :     &FIG::verify_dir($work_dir);
367 :    
368 :     my $upload_job = new JobUpload($work_dir);
369 :     my $errs = [];
370 :    
371 :     my $fh;
372 :     if (!open($fh, "<", \$file))
373 :     {
374 :     my $er = $!;
375 :     my $len = length($file);
376 :     system("rm", "-r", $work_dir);
377 :     return { status => 'error', error_msg => "error creating filehandle from file data of length $len: $er" };
378 :     }
379 :    
380 :     if (!$upload_job->create_from_filehandle($fh, "rast_submission_file", $errs))
381 :     {
382 :     system("rm", "-r", $work_dir);
383 :     return { status => 'error', error_msg => join("\n", @$errs) };
384 :     }
385 :    
386 :     my $meta_obj = $upload_job->meta();
387 :    
388 :     #
389 :     # Pull the metadata into a hash, where it's easier to use
390 :     # and so that we can just return it to our caller if everything
391 :     # is good to go.
392 :     #
393 :    
394 :     my %meta = map { $_ => $meta_obj->get_metadata($_) } $meta_obj->get_metadata_keys();
395 :    
396 :     my $res = { upload_metadata => \%meta };
397 :    
398 :     #
399 :     # We have parsed the file. Let's do some error checking.
400 :     #
401 :    
402 :     if ($meta{upload_type} ne $filetype)
403 :     {
404 :     $res->{status} = 'error';
405 :     $res->{error_msg} = "Parsed filetype $meta{upload_type} not the expected $filetype";
406 :     system("rm", "-r", $work_dir);
407 :     return $res;
408 :     }
409 :    
410 :     #
411 :     # Do an NCBI lookup to pull the taxonomy string for the given tax id (if provided)
412 :     #
413 :    
414 :     my $taxonomy;
415 :     if ($tax_id)
416 :     {
417 :     my $tdata = $self->get_taxonomy_data($tax_id);
418 :     if ($tdata)
419 :     {
420 :     $domain = $tdata->{domain} unless defined($domain);
421 :     $genetic_code = $tdata->{genetic_code} unless defined($genetic_code);
422 :     $taxonomy = $tdata->{taxonomy};
423 :     }
424 :     }
425 :     else
426 :     {
427 :     $tax_id = '666666';
428 :     $taxonomy = $domain;
429 :     }
430 :    
431 :     #
432 :     # That's all for now; we might add more later.
433 :     # Use Job48 to create the job. We create another slightly
434 :     # different parameter hash for this.
435 :     #
436 :    
437 :     #
438 :     # Find the file we're using.
439 :     #
440 :     my($clean_file, $clean_fh);
441 :     if ($meta{upload_type} eq 'genbank')
442 :     {
443 :     $clean_file = $meta{clean_genbank};
444 :     }
445 :     elsif ($meta{upload_type} eq 'fasta')
446 :     {
447 :     $clean_file = $meta{clean_fasta};
448 :     }
449 :     $clean_fh = new FileHandle($clean_file, "<");
450 :    
451 :     my $j48_data = {
452 :     genome => $organism,
453 :     project => $self->user_obj->login."_".$tax_id,
454 :     user => $self->user_obj->login,
455 :     taxonomy => $taxonomy ."; $organism",
456 :     taxonomy_id => $tax_id,
457 :     genetic_code => $genetic_code,
458 :     sequence_file => $clean_fh,
459 :     meta => {
460 :     source_file => $clean_file,
461 :     'genome.genetic_code' => $genetic_code,
462 :     'genome.sequencing_method' => 'unknown',
463 :     'genome.coverage' => 'unknown',
464 :     'genome.contigs' => 'unknown',
465 :     'genome.average_read_length' => 'unknown',
466 :     'genome.gc_content' => $meta{stats_contigs}->{gc},
467 :     'genome.bp_count' => $meta{stats_contigs}->{chars},
468 :     'genome.contig_count' => $meta{stats_contigs}->{seqs},
469 :     'genome.ambig_count' => 0,
470 :     'import.candidate' => 0,
471 :     'keep_genecalls' => $keep ? 1 : 0,
472 :     'use_glimmer' => $gene_caller eq 'glimmer3' ? 1 : 0,
473 :     'correction.automatic' => 1,
474 :     'correction.frameshifts' => 0,
475 :     'correction.backfill_gaps' => 1,
476 :     'env.debug' => 0,
477 :     'env.verbose' => 0,
478 :     upload_metadata => \%meta,
479 :     },
480 :     };
481 :    
482 :     my($job_id, $job_msg) = Job48->create_new_job($j48_data);
483 :     if ($job_id)
484 :     {
485 :     $res->{status} = 'ok';
486 :     $res->{job_id} = $job_id;
487 :    
488 :    
489 :     # sync job so it'll appear in the job listings on the website
490 :     my $sync;
491 :     eval { $sync = $self->rast_dbmaster->Job->init({ id => $job_id }); };
492 :     }
493 :     else
494 :     {
495 :     $res->{status} = 'error';
496 :     $res->{error_msg} = $job_msg;
497 :     }
498 :     close($clean_fh);
499 :     system("rm", "-r", $work_dir);
500 : olson 1.5 return $res;
501 : olson 1.1 }
502 :    
503 :     sub status_of_RAST_job
504 :     {
505 :     my($self, $params) = @_;
506 :    
507 : olson 1.2 my @job_nums;
508 :     my $job_num_param = $params->{-job};
509 :     if (ref($job_num_param) eq 'ARRAY')
510 : olson 1.1 {
511 : olson 1.2 @job_nums = @$job_num_param;
512 : olson 1.1 }
513 : olson 1.2 else
514 :     {
515 :     @job_nums = ($job_num_param);
516 :     }
517 :    
518 :     my $res = {};
519 :     for my $job_num (@job_nums)
520 :     {
521 :     my $job = $self->rast_dbmaster->Job->init({ id => $job_num });
522 :     if (!ref($job))
523 :     {
524 :     $res->{$job_num} = { status => 'error', error_msg => 'Job not found'};
525 :     next;
526 :     }
527 :    
528 :     if (!$self->user_may_access_job($job))
529 :     {
530 :     $res->{$job_num} = { status => 'error', error_msg => 'Access denied' };
531 :     next;
532 :     }
533 :    
534 :     my $dir = $job->dir;
535 :     if (open(E, "<$dir/ERROR"))
536 :     {
537 :     local $/;
538 :     undef $/;
539 :     my $emsg = <E>;
540 :     close(E);
541 :     $res->{job_num} = { status => 'error', error_msg => $emsg };
542 :     next;
543 :     }
544 :    
545 :     #
546 :     # Retrieve status flags from the meta file (not the database,
547 :     # so that we can get the very latest state).
548 :     #
549 :    
550 :     #
551 :     # For now we only check status.export because that is what the
552 :     # bulk API cares about.
553 :     #
554 :    
555 :     my $status_list = [];
556 :     my $cur_stage;
557 :     my $stages = $job->stages();
558 :     my %status;
559 :     for my $stage (@$stages)
560 :     {
561 :     my $status = $job->metaxml->get_metadata($stage) || 'not_started';
562 :     $status{$stage} = $status;
563 :     push(@$status_list, [$stage => $status]);
564 :     if ($status ne 'complete')
565 :     {
566 :     $cur_stage = $stage;
567 :     }
568 :     }
569 :    
570 : olson 1.7 #
571 :     # If any stage is not in not_started, then the job is running.
572 :     #
573 :     my $exp_status = $status{'status.export'};
574 :     if ($exp_status ne 'complete')
575 :     {
576 :     if (grep { $status{$_} ne 'not_started' } keys %status)
577 :     {
578 :     $exp_status = 'running';
579 :     }
580 :     }
581 :    
582 :     $res->{$job_num} = { status => $exp_status, verbose_status => $status_list };
583 :     }
584 :     return $res;
585 :     }
586 :    
587 :     =head3 kill_RAST_job
588 :    
589 :     Mark the job as inactive, and qdel any stages that might be running.
590 :    
591 :     =cut
592 :     sub kill_RAST_job
593 :     {
594 :     my($self, $params) = @_;
595 :    
596 :     my @job_nums;
597 :     my $job_num_param = $params->{-job};
598 :     if (ref($job_num_param) eq 'ARRAY')
599 :     {
600 :     @job_nums = @$job_num_param;
601 :     }
602 :     else
603 :     {
604 :     @job_nums = ($job_num_param);
605 :     }
606 :    
607 :     my $res = {};
608 :     for my $job_num (@job_nums)
609 :     {
610 :     my $job = $self->rast_dbmaster->Job->init({ id => $job_num });
611 :     if (!ref($job))
612 :     {
613 :     $res->{$job_num} = { status => 'error', error_msg => 'Job not found'};
614 :     next;
615 :     }
616 :    
617 :     if (!$self->user_may_access_job($job))
618 :     {
619 :     $res->{$job_num} = { status => 'error', error_msg => 'Access denied' };
620 :     next;
621 :     }
622 :    
623 :     my $messages = [];
624 :     my @ids;
625 :     for my $k ($job->metaxml->get_metadata_keys())
626 :     {
627 :     if ($k =~ /sge[^.]*id/)
628 :     {
629 :     my $id = $job->metaxml->get_metadata($k);
630 :     if (ref($id))
631 :     {
632 :     push(@ids, @$id);
633 :     }
634 :     else
635 :     {
636 :     push(@ids, $id);
637 :     }
638 :     }
639 :     }
640 :    
641 :     #
642 :     # sanity check.
643 :     #
644 :     @ids = grep { /^\d+$/ } @ids;
645 :    
646 :     if (@ids)
647 :     {
648 :     my $cmd = ". /vol/sge/default/common/settings.sh; qdel @ids";
649 :     if (open(my $p, "$cmd 2>&1 |"))
650 :     {
651 :     while (<$p>)
652 :     {
653 :     chomp;
654 :     push(@$messages, $_);
655 :     }
656 :    
657 :     my $rc = close($p);
658 :     if (!$rc)
659 :     {
660 :     push(@$messages, "'$cmd' returns status=$! $?");
661 :     }
662 :     else
663 :     {
664 :     push(@$messages, "'$cmd' returns status=0");
665 :     }
666 :     }
667 :     else
668 :     {
669 :     push(@$messages, "Cannot open pipe to $cmd: $!");
670 :     }
671 :     }
672 :     else
673 :     {
674 :     push(@$messages, "No sge tasks to kill");
675 :     }
676 :    
677 :     my $active = $job->dir . "/ACTIVE";
678 :     if (-f $active)
679 :     {
680 :     if (unlink($active))
681 :     {
682 :     push(@$messages, "unlinked $active");
683 :     }
684 :     else
685 :     {
686 :     push(@$messages, "error unlinking $active: $!");
687 :     }
688 :     }
689 :     else
690 :     {
691 :     push(@$messages, "no active file $active");
692 :     }
693 :     $res->{$job_num} = { status => 'ok', messages => $messages };
694 : olson 1.2 }
695 :     return $res;
696 :     }
697 : olson 1.1
698 : olson 1.7 =head3 delete_RAST_job
699 :    
700 :     Delete the given RAST jobs. This is a real delete, not a mark-the-flag delete.
701 :    
702 :     =cut
703 :     sub delete_RAST_job
704 :     {
705 :     my($self, $params) = @_;
706 :    
707 :     my @job_nums;
708 :     my $job_num_param = $params->{-job};
709 :     if (ref($job_num_param) eq 'ARRAY')
710 :     {
711 :     @job_nums = @$job_num_param;
712 :     }
713 :     else
714 :     {
715 :     @job_nums = ($job_num_param);
716 :     }
717 :    
718 :     my $res = {};
719 :     for my $job_num (@job_nums)
720 :     {
721 :     my $job = $self->rast_dbmaster->Job->init({ id => $job_num });
722 :     if (!ref($job))
723 :     {
724 :     $res->{$job_num} = { status => 'error', error_msg => 'Job not found'};
725 :     next;
726 :     }
727 :    
728 :     if (!$self->user_may_access_job($job))
729 :     {
730 :     $res->{$job_num} = { status => 'error', error_msg => 'Access denied' };
731 :     next;
732 :     }
733 :    
734 :     my $dir = $job->dir;
735 :    
736 :     #
737 :     # Just make sure the dir ends in the job number, so an error
738 :     # doesn't wreak TOO much havoc.
739 :     #
740 :     if ($dir =~ /$job_num$/)
741 :     {
742 :     my $rc = system("rm", "-r", $dir);
743 :     if ($rc == 0)
744 :     {
745 :     $res->{$job_num} = { status => 'ok' }
746 :     }
747 :     else
748 :     {
749 :     $res->{$job_num} = { status => 'error', error_msg => "Remove of $dir died with status $rc" }
750 :     }
751 :     }
752 :     #
753 :     # Delete from the database too.
754 :     #
755 :     $job->delete();
756 :     }
757 :    
758 :     return $res;
759 :     }
760 :    
761 : olson 1.3 sub retrieve_RAST_job
762 :     {
763 :     my($self, $params) = @_;
764 :    
765 :     my $job_id = $params->{-job};
766 :     my $format = $params->{-format};
767 :    
768 :     my $job = $self->rast_dbmaster->Job->init({ id => $job_id });
769 :    
770 :     if (!ref($job))
771 :     {
772 :     return { status => 'error', error_msg => 'Job not found'};
773 :     }
774 :    
775 :     if (!$self->user_may_access_job($job))
776 :     {
777 :     return { status => 'error', error_msg => 'Access denied' };
778 :     }
779 :    
780 :     #
781 :     # Map the given output format to a file.
782 :     #
783 :    
784 :     my %type_map = (genbank => "%s.gbk",
785 :     genbank_stripped => "%s.ec-stripped.gbk",
786 :     embl => "%s.embl",
787 :     embl_stripped => "%s.ec-stripped.embl",
788 :     gff3 => "%s.gff",
789 :     gff3_stripped => "%s.ec-stripped.gff",
790 :     gtf => "%s.gtf",
791 :     rast_tarball => "%s.tgz",
792 :     );
793 :    
794 :     my $file_pattern = $type_map{lc($format)};
795 :     if (!defined($file_pattern))
796 :     {
797 :     return { status => 'error', error_msg => "Format $format not found" };
798 :     }
799 :    
800 :     #
801 :     # Find the download file.
802 :     #
803 :    
804 :     my $dir = $job->download_dir();
805 :     my $file = sprintf($file_pattern, $job->genome_id);
806 :     my $path = "$dir/$file";
807 :     if (!open(F, "<", $path))
808 :     {
809 :     return { status => 'error', error_msg => "Cannot open download file $path"};
810 :     }
811 :    
812 :     local $/;
813 :     undef $/;
814 :     my $txt = <F>;
815 :     return { status => 'ok', contents => $txt };
816 :     }
817 :    
818 : olson 1.2 sub user_may_access_job
819 :     {
820 :     my($self, $job_id) = @_;
821 : olson 1.1
822 : olson 1.2 return 1;
823 : olson 1.1 }
824 :    
825 :    
826 :     1;

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3