Commit a174bbb6 authored by Matthieu Muffato's avatar Matthieu Muffato
Browse files

Last merge before the pull-request

Merge remote-tracking branch 'ensembl-github/master' into python

* ensembl-github/master:
  moved mysql_use_result=>1 to the $sth_attribs hash
  allow capturing dataflow from a standaloneJob into a semaphored group
  Dataflow rules are stored in the Analysis, not the Job
  bugfix: make sure dataflown jobs are stored even in standalone mode
  generalized load_parameters() moved into AnalysisJob
  bugfix [to 97e17d94] : removed the leading zero from param_init call in gc_dataflow
  The $a syntax in #expr() has long gone, Should use #a# instead
  Deprecate --append in db_cmd.pl
  deprecated and removed support for strict_hash_format() method in Runnables
  We don't use $SKIP_TESTS in ensembl-hive

Conflicts:
	modules/Bio/EnsEMBL/Hive/Worker.pm
	t/10.pipeconfig/longmult.t
parents f4816bec fa49be74
......@@ -153,6 +153,9 @@ sub get_compiled_module_name {
die "Problem accessing methods in '$runnable_module_name'. Please check that it inherits from Bio::EnsEMBL::Hive::Process and is named correctly.\n"
unless($runnable_module_name->isa('Bio::EnsEMBL::Hive::Process'));
die "DEPRECATED: the strict_hash_format() method is no longer supported in Runnables - the input_id() in '$runnable_module_name' has to be a hash now.\n"
if($runnable_module_name->can('strict_hash_format'));
return $runnable_module_name;
}
......@@ -230,7 +233,24 @@ sub control_rules_collection {
sub dataflow_rules_collection {
my $self = shift @_;
return Bio::EnsEMBL::Hive::DataflowRule->collection()->find_all_by('from_analysis', $self);
my $collection = Bio::EnsEMBL::Hive::DataflowRule->collection();
return $collection->find_all_by('from_analysis', $self);
}
sub dataflow_rules_by_branch {
my $self = shift @_;
if (not $self->{'_dataflow_rules_by_branch'}) {
my %dataflow_rules_by_branch = ();
foreach my $dataflow (@{$self->dataflow_rules_collection}) {
push @{$dataflow_rules_by_branch{$dataflow->branch_code}}, $dataflow;
}
$self->{'_dataflow_rules_by_branch'} = \%dataflow_rules_by_branch;
}
return $self->{'_dataflow_rules_by_branch'};
}
......
......@@ -40,6 +40,7 @@ use strict;
use warnings;
use Bio::EnsEMBL::Hive::Utils ('stringify', 'destringify');
use Bio::EnsEMBL::Hive::DBSQL::AccumulatorAdaptor;
use Bio::EnsEMBL::Hive::DBSQL::AnalysisJobAdaptor;
use Bio::EnsEMBL::Hive::DBSQL::DataflowRuleAdaptor;
......@@ -144,21 +145,6 @@ sub set_and_update_status {
}
}
sub dataflow_rules { # if ever set will prevent the Job from fetching rules from the DB
my $self = shift @_;
my $branch_name_or_code = shift @_;
my $branch_code = Bio::EnsEMBL::Hive::DBSQL::DataflowRuleAdaptor::branch_name_2_code($branch_name_or_code);
if(@_) {
$self->{'_dataflow_rules'}{$branch_code} = shift @_;
}
$self->{'_dataflow_rules'} ||= $self->adaptor->db->get_DataflowRuleAdaptor->fetch_all_by_from_analysis_id_HASHED_FROM_branch_code( $self->analysis_id );
return $self->{'_dataflow_rules'}{$branch_code} || [];
}
sub stdout_file {
my $self = shift;
$self->{'_stdout_file'} = shift if(@_);
......@@ -239,6 +225,37 @@ sub died_somewhere {
##-----------------[/indicators to the Worker]-------------------------------
sub load_parameters {
my ($self, $runnable_object) = @_;
my @params_precedence = ();
push @params_precedence, $runnable_object->param_defaults if($runnable_object);
if(my $job_adaptor = $self->adaptor) {
my $job_id = $self->dbID;
my $accu_adaptor = $job_adaptor->db->get_AccumulatorAdaptor;
$self->accu_hash( $accu_adaptor->fetch_structures_for_job_ids( $job_id )->{ $job_id } );
push @params_precedence, $job_adaptor->db->get_PipelineWideParametersAdaptor->fetch_param_hash;
push @params_precedence, $self->analysis->parameters if($self->analysis);
if( $job_adaptor->db->hive_use_param_stack ) {
my $input_ids_hash = $job_adaptor->fetch_input_ids_for_job_ids( $self->param_id_stack, 2, 0 ); # input_ids have lower precedence (FOR EACH ID)
my $accu_hash = $accu_adaptor->fetch_structures_for_job_ids( $self->accu_id_stack, 2, 1 ); # accus have higher precedence (FOR EACH ID)
my %input_id_accu_hash = ( %$input_ids_hash, %$accu_hash );
push @params_precedence, @input_id_accu_hash{ sort { $a <=> $b } keys %input_id_accu_hash }; # take a slice. Mmm...
}
}
push @params_precedence, $self->input_id, $self->accu_hash;
$self->param_init( @params_precedence );
}
sub fan_cache { # a self-initializing getter (no setting)
# Returns a hash-of-lists { 2 => [list of jobs waiting to be funneled into 2], 3 => [list of jobs waiting to be funneled into 3], etc}
my $self = shift;
......@@ -268,8 +285,8 @@ sub dataflow_output_id {
my $param_id_stack = $self->param_id_stack();
my $accu_id_stack = $self->accu_id_stack();
my $job_adaptor = $self->adaptor();
my $hive_use_param_stack = $job_adaptor && $job_adaptor->db->hive_use_param_stack();
my $job_adaptor = $self->adaptor() || 'Bio::EnsEMBL::Hive::DBSQL::AnalysisJobAdaptor';
my $hive_use_param_stack = ref($job_adaptor) && $job_adaptor->db->hive_use_param_stack();
if($hive_use_param_stack) {
if($input_id and ($input_id ne '{}')) { # add the parent to the param_id_stack if it had non-trivial extra parameters
......@@ -296,7 +313,7 @@ sub dataflow_output_id {
my @output_job_ids = ();
# sort rules to make sure the fan rules come before funnel rules for the same branch_code:
foreach my $rule (sort {($b->funnel_dataflow_rule_id||0) <=> ($a->funnel_dataflow_rule_id||0)} @{ $self->dataflow_rules( $branch_code ) }) {
foreach my $rule (sort {($b->funnel_dataflow_rule//0) cmp ($a->funnel_dataflow_rule//0)} @{ $self->analysis->dataflow_rules_by_branch->{$branch_code} || [] }) {
# parameter substitution into input_id_template is rule-specific
my $output_ids_for_this_rule;
......@@ -313,23 +330,29 @@ sub dataflow_output_id {
$target_analysis_or_table->dataflow( $output_ids_for_this_rule, $self );
} elsif(my $funnel_dataflow_rule_id = $rule->funnel_dataflow_rule_id()) { # members of a semaphored fan will have to wait in cache until the funnel is created:
} else {
my @common_params = (
'prev_job' => $self,
'analysis' => $target_analysis_or_table, # expecting an Analysis
'param_id_stack' => $param_id_stack,
'accu_id_stack' => $accu_id_stack,
);
if( my $funnel_dataflow_rule = $rule->funnel_dataflow_rule ) { # members of a semaphored fan will have to wait in cache until the funnel is created:
my $fan_cache_this_branch = $self->fan_cache()->{$funnel_dataflow_rule_id} ||= [];
my $fan_cache_this_branch = $self->fan_cache->{"$funnel_dataflow_rule"} ||= [];
push @$fan_cache_this_branch, map { Bio::EnsEMBL::Hive::AnalysisJob->new(
'prev_job' => $self,
'analysis' => $target_analysis_or_table, # expecting an Analysis
@common_params,
'input_id' => $_,
'param_id_stack' => $param_id_stack,
'accu_id_stack' => $accu_id_stack,
# semaphored_job_id => to be set when the $funnel_job has been stored
) } @$output_ids_for_this_rule;
} else { # either a semaphored funnel or a non-semaphored dataflow:
} else { # either a semaphored funnel or a non-semaphored dataflow:
my $fan_jobs = delete $self->fan_cache()->{$rule->dbID}; # clear the cache at the same time
my $fan_jobs = delete $self->fan_cache->{"$rule"}; # clear the cache at the same time
if($fan_jobs && @$fan_jobs) { # a semaphored funnel
if( $fan_jobs && @$fan_jobs ) { # a semaphored funnel
if( (my $funnel_job_count = scalar(@$output_ids_for_this_rule)) !=1 ) {
......@@ -338,11 +361,8 @@ sub dataflow_output_id {
} else {
my $funnel_job = Bio::EnsEMBL::Hive::AnalysisJob->new(
'prev_job' => $self,
'analysis' => $target_analysis_or_table, # expecting an Analysis
@common_params,
'input_id' => $output_ids_for_this_rule->[0],
'param_id_stack' => $param_id_stack,
'accu_id_stack' => $accu_id_stack,
'semaphore_count' => scalar(@$fan_jobs), # "pre-increase" the semaphore count before creating the dependent jobs
'semaphored_job_id' => $self->semaphored_job_id(), # propagate parent's semaphore if any
);
......@@ -357,7 +377,6 @@ sub dataflow_output_id {
if( $funnel_job->status eq 'SEMAPHORED' ) {
$job_adaptor->increase_semaphore_count_for_jobid( $funnel_job_id, scalar(@$fan_jobs) ); # "pre-increase" the semaphore count before creating the dependent jobs
# $job_adaptor->db->get_LogMessageAdaptor->store_job_message($self->dbID, "Failed to store the funnel job, but fetched it still SEMAPHORED from the DB (id=$funnel_job_id)", 0);
$job_adaptor->db->get_LogMessageAdaptor->store_job_message($self->dbID, "Discovered and using an existing funnel ".$funnel_job->toString, 0);
} else {
die "The funnel job (id=$funnel_job_id) fetched from the database was not in SEMAPHORED status";
......@@ -375,17 +394,16 @@ sub dataflow_output_id {
}
} else { # non-semaphored dataflow (but potentially propagating any existing semaphores)
my @non_semaphored_jobs = map { Bio::EnsEMBL::Hive::AnalysisJob->new(
'prev_job' => $self,
'analysis' => $target_analysis_or_table, # expecting an Analysis
@common_params,
'input_id' => $_,
'param_id_stack' => $param_id_stack,
'accu_id_stack' => $accu_id_stack,
'semaphored_job_id' => $self->semaphored_job_id(), # propagate parent's semaphore if any
) } @$output_ids_for_this_rule;
push @output_job_ids, @{ $job_adaptor->store_jobs_and_adjust_counters( \@non_semaphored_jobs, 0) };
}
} # /if
} # /if funnel
} # /if (table or analysis)
} # /foreach my $rule
return \@output_job_ids;
......
......@@ -95,7 +95,7 @@ sub store_jobs_and_adjust_counters {
my $analysis = $job->analysis;
my $job_adaptor = $analysis ? $analysis->adaptor->db->get_AnalysisJobAdaptor : $self; # if analysis object is undefined, consider the job local
my $local_job = $job_adaptor == $self;
my $local_job = $job_adaptor eq $self;
# avoid deadlocks when dataflowing under transactional mode (used in Ortheus Runnable for example):
if($need_to_increase_semaphore_count and $local_job and ($job_adaptor->dbc->driver ne 'sqlite')) {
......@@ -574,8 +574,9 @@ sub gc_dataflow {
}
my $job = $self->fetch_by_dbID($job_id);
$job->analysis( $analysis );
$job->param_init( 0, $analysis->parameters(), $job->input_id() ); # input_id_templates still supported, however to a limited extent
$job->load_parameters(); # input_id_templates still supported, however to a limited extent
$job->dataflow_output_id( $job->input_id() , $branch_name );
......
......@@ -101,24 +101,19 @@ sub new {
sub param_init {
my $self = shift @_;
my $strict_hash_format = shift @_;
my %unsubstituted_param_hash = ();
foreach my $source (@_) {
if(ref($source) ne 'HASH') {
if($strict_hash_format or $source=~/^\{.*\}$/) {
my $param_hash = eval($source) || {};
if($@ or (ref($param_hash) ne 'HASH')) {
if($self->can('transient_error')) {
$self->transient_error(0);
}
die "Expected a {'param'=>'value'} hashref, but got the following string instead: '$source'\n";
my $param_hash = eval($source) || {};
if($@ or (ref($param_hash) ne 'HASH')) {
if($self->can('transient_error')) {
$self->transient_error(0);
}
$source = $param_hash;
} else {
$source = {};
die "Expected a {'param'=>'value'} hashref, but got the following string instead: '$source'\n";
}
$source = $param_hash;
}
while(my ($k,$v) = each %$source ) {
$unsubstituted_param_hash{$k} = $v;
......@@ -232,7 +227,7 @@ sub param_is_defined {
Arg [2] : (optional) $param_value
Description: A getter/setter method for a job's parameters that are initialized through 4 levels of precedence (see param_init() )
Description: A getter/setter method for a job's parameters that are initialized through multiple levels of precedence (see param_init() )
Example 1 : my $source = $self->param('source'); # acting as a getter
......
......@@ -90,7 +90,7 @@ sub pipeline_analyses {
{ -logic_name => 'generate_jobs',
-module => 'Bio::EnsEMBL::Hive::RunnableDB::JobFactory',
-parameters => {
'inputlist' => '#expr([0..$job_count-1])expr#', # this expression will evaluate into a listref
'inputlist' => '#expr([0..#job_count#-1])expr#', # this expression will evaluate into a listref
'column_names' => [ 'value' ],
},
-input_ids => [
......
......@@ -239,18 +239,6 @@ sub warning {
#
##########################################
=head2 strict_hash_format
Title : strict_hash_format
Function: if a subclass wants more flexibility in parsing job.input_id and analysis.parameters,
it should redefine this method to return 0
=cut
sub strict_hash_format {
return 1;
}
=head2 param_defaults
......
......@@ -249,6 +249,9 @@ sub specialize_worker {
#
# it is easier to preload all Stats objects:
Bio::EnsEMBL::Hive::AnalysisStats->collection( Bio::EnsEMBL::Hive::Utils::Collection->new( $self->db->get_AnalysisStatsAdaptor->fetch_all ) );
#
# preload all the DFRs here as well:
Bio::EnsEMBL::Hive::DataflowRule->collection( Bio::EnsEMBL::Hive::Utils::Collection->new( $self->db->get_DataflowRuleAdaptor->fetch_all ) );
$analysis = Bio::EnsEMBL::Hive::Scheduler::suggest_analysis_to_specialize_a_worker($worker, $analyses_matching_pattern, $analyses_pattern);
......
......@@ -52,10 +52,6 @@ use Time::HiRes ('usleep');
use base ('Bio::EnsEMBL::Hive::Process');
sub strict_hash_format { # allow this Runnable to parse parameters in its own way (don't complain)
return 0;
}
=head2 param_defaults
Description : Implements param_defaults() interface method of Bio::EnsEMBL::Hive::Process that defines module defaults for parameters.
......
......@@ -56,25 +56,13 @@ use warnings;
use base ('Bio::EnsEMBL::Hive::Process');
=head2 strict_hash_format
Description : Implements strict_hash_format() interface method of Bio::EnsEMBL::Hive::Process that is used to set the strictness level of the parameters' parser.
Here we return 0 in order to indicate that neither input_id() nor parameters() is required to contain a hash.
=cut
sub strict_hash_format {
return 0;
}
=head2 fetch_input
=head2 run
Description : Implements fetch_input() interface method of Bio::EnsEMBL::Hive::Process that is used to read in parameters and load data.
Here it deals with finding the sql command(s), doing parameter substitution, storing the result in a predefined place
and optionally connecting to another database (see param('db_conn')).
Description : Implements run() interface method of Bio::EnsEMBL::Hive::Process that is used to perform the main bulk of the job (minus input and output).
Here it actually runs the sql command(s). If a list of commands is given, they are run in succession within the same session
(so you can create a temporary tables and use it in another command within the same sql command list).
param('sql'): The recommended way of passing in the sql command(s).
param('sql'): Either a scalar SQL command or an array of SQL commands.
param('db_conn'): An optional hash to pass in connection parameters to the database upon which the sql command(s) will have to be run.
......@@ -82,34 +70,12 @@ sub strict_hash_format {
=cut
sub fetch_input {
my $self = shift;
# First, FIND the sql command
#
my $sql = ($self->input_id()!~/^\{.*\}$/)
? $self->input_id() # assume the sql command is given in input_id
: $self->param('sql') # or defined as a hash value (in input_id or parameters)
or die "Could not find the command defined in param('sql') or input_id()";
# Store the sql command array:
#
$self->param('sqls', (ref($sql) eq 'ARRAY') ? $sql : [$sql] );
}
=head2 run
Description : Implements run() interface method of Bio::EnsEMBL::Hive::Process that is used to perform the main bulk of the job (minus input and output).
Here it actually runs the sql command(s). If a list of commands is given, they are run in succession within the same session
(so you can create a temporary tables and use it in another command within the same sql command list).
=cut
sub run {
my $self = shift;
my $sqls = $self->param('sqls');
my $sqls = $self->param_required('sql');
$sqls = [$sqls] if(ref($sqls) ne 'ARRAY');
my $data_dbc = $self->data_dbc();
my %output_id;
......
......@@ -157,8 +157,9 @@ sub _run_test {
$query .= " LIMIT $maxrow" unless $query =~ /LIMIT/i;
print "Query: $query\n";
my $sth = $self->data_dbc()->prepare($query);
$sth->{mysql_use_result} = 1 if $self->data_dbc->driver eq 'mysql';
my $sth_attribs = ($self->data_dbc->driver eq 'mysql') ? { 'mysql_use_result' => 1 } : {};
my $sth = $self->data_dbc()->prepare($query, $sth_attribs);
$sth->execute();
my $nrow = 0;
......
......@@ -76,46 +76,6 @@ sub param_defaults {
}
=head2 strict_hash_format
Description : Implements strict_hash_format() interface method of Bio::EnsEMBL::Hive::Process that is used to set the strictness level of the parameters' parser.
Here we return 0 in order to indicate that neither input_id() nor parameters() is required to contain a hash.
=cut
sub strict_hash_format {
return 0;
}
=head2 fetch_input
Description : Implements fetch_input() interface method of Bio::EnsEMBL::Hive::Process that is used to read in parameters and load data.
Here it deals with finding the command line, doing parameter substitution and storing the result in a predefined place.
param('cmd'): The recommended way of passing in the command line. It can be either a string, or an array-ref of strings. The later is safer if some of the
arguments contain white-spaces.
param('*'): Any other parameters can be freely used for parameter substitution.
=cut
sub fetch_input {
my $self = shift;
# First, FIND the command line
#
my $cmd = ($self->input_id()!~/^\{.*\}$/)
? $self->input_id() # assume the command line is given in input_id
: $self->param('cmd') # or defined as a hash value (in input_id or parameters)
or die "Could not find the command defined in param('cmd') or input_id()";
# Store the value with parameter substitutions for the actual execution:
#
$self->param('cmd', $cmd);
}
=head2 text_to_shell_lit
Argument[0]: String
......@@ -141,12 +101,17 @@ sub text_to_shell_lit(_) {
Description : Implements run() interface method of Bio::EnsEMBL::Hive::Process that is used to perform the main bulk of the job (minus input and output).
Here it actually runs the command line.
param('cmd'): The recommended way of passing in the command line. It can be either a string, or an array-ref of strings. The later is safer if some of the
arguments contain white-spaces.
param('*'): Any other parameters can be freely used for parameter substitution.
=cut
sub run {
my $self = shift;
my $cmd = $self->param('cmd');
my $cmd = $self->param_required('cmd');
my ($join_needed, $flat_cmd) = join_command_args($cmd);
# Let's use the array if possible, it saves us from running a shell
my @cmd_to_run = $join_needed ? $flat_cmd : (ref($cmd) ? @$cmd : $cmd);
......
......@@ -38,37 +38,86 @@ sub standaloneJob {
$runnable_object->debug($flags->{debug}) if $flags->{debug};
$runnable_object->execute_writes(not $flags->{no_write});
my $job = Bio::EnsEMBL::Hive::AnalysisJob->new( 'dbID' => -1 );
die "Dummy job not created\n" unless $job;
$job->input_id( $input_id );
$job->dataflow_rules(1, []);
my $dummy_analysis = Bio::EnsEMBL::Hive::Analysis->new(
'logic_name' => 'Standalone_Dummy_Analysis', # looks nicer when printing out DFRs
'dbID' => -1,
);
$job->param_init( $runnable_object->strict_hash_format(), $runnable_object->param_defaults(), $job->input_id() );
my $job = Bio::EnsEMBL::Hive::AnalysisJob->new(
'analysis' => $dummy_analysis,
'input_id' => $input_id,
'dbID' => -1,
);
$job->load_parameters( $runnable_object );
Bio::EnsEMBL::Hive::DataflowRule->collection( Bio::EnsEMBL::Hive::Utils::Collection->new() );
$flow_into = $flow_into ? destringify($flow_into) : []; # empty dataflow for branch 1 by default
$flow_into = { 1 => $flow_into } unless(ref($flow_into) eq 'HASH'); # force non-hash into a hash
foreach my $branch_code (keys %$flow_into) {
my $heirs = $flow_into->{$branch_code};
$heirs = [ $heirs ] unless(ref($heirs)); # force scalar into an arrayref first
$heirs = { map { ($_ => undef) } @$heirs } if(ref($heirs) eq 'ARRAY'); # now force it into a hash if it wasn't
# -------------------------------------------- DFR parser cloned from HiveGeneric_conf
my @dataflow_rules = ();
$flow_into = { 1 => $flow_into } unless(ref($flow_into) eq 'HASH'); # force non-hash into a hash
while(my ($heir_url, $input_id_template_list) = each %$heirs) {
my %group_tag_to_funnel_dataflow_rule = ();
$input_id_template_list = [ $input_id_template_list ] unless(ref($input_id_template_list) eq 'ARRAY'); # allow for more than one template per analysis
my $semaphore_sign = '->';
foreach my $input_id_template (@$input_id_template_list) {
my @all_branch_tags = keys %$flow_into;
foreach my $branch_tag ((grep {/^[A-Z]$semaphore_sign/} @all_branch_tags), (grep {/$semaphore_sign[A-Z]$/} @all_branch_tags), (grep {!/$semaphore_sign/} @all_branch_tags)) {
push @dataflow_rules, Bio::EnsEMBL::Hive::DataflowRule->new(
'to_analysis_url' => $heir_url,
'input_id_template' => $input_id_template,
);
my ($branch_name_or_code, $group_role, $group_tag);
if($branch_tag=~/^([A-Z])$semaphore_sign(-?\w+)$/) {
($branch_name_or_code, $group_role, $group_tag) = ($2, 'funnel', $1);
} elsif($branch_tag=~/^(-?\w+)$semaphore_sign([A-Z])$/) {
($branch_name_or_code, $group_role, $group_tag) = ($1, 'fan', $2);
} elsif($branch_tag=~/^(-?\w+)$/) {
($branch_name_or_code, $group_role, $group_tag) = ($1, '');
} elsif($branch_tag=~/:/) {
die "Please use newer '2${semaphore_sign}A' and 'A${semaphore_sign}1' notation instead of '2:1' and '1'\n";
} else {
die "Error parsing the group tag '$branch_tag'\n";
}
}
$job->dataflow_rules( $branch_code, \@dataflow_rules );
}
my $funnel_dataflow_rule = undef; # NULL by default
if($group_role eq 'fan') {
unless($funnel_dataflow_rule = $group_tag_to_funnel_dataflow_rule{$group_tag}) {
die "No funnel dataflow_rule defined for group '$group_tag'\n";
}
}
my $heirs = $flow_into->{$branch_tag};
$heirs = [ $heirs ] unless(ref($heirs)); # force scalar into an arrayref first
$heirs = { map { ($_ => undef) } @$heirs } if(ref($heirs) eq 'ARRAY'); # now force it into a hash if it wasn't
while(my ($heir_url, $input_id_template_list) = each %$heirs) {
$input_id_template_list = [ $input_id_template_list ] unless(ref($input_id_template_list) eq 'ARRAY'); # allow for more than one template per analysis
foreach my $input_id_template (@$input_id_template_list) {
my $df_rule = Bio::EnsEMBL::Hive::DataflowRule->add_new_or_update(
'from_analysis' => $dummy_analysis,
'to_analysis_url' => $heir_url,
'branch_code' => $branch_name_or_code,
'funnel_dataflow_rule' => $funnel_dataflow_rule,
'input_id_template' => $input_id_template,
);
if($group_role eq 'funnel') {
if($group_tag_to_funnel_dataflow_rule{$group_tag}) {
die "More than one funnel dataflow_rule defined for group '$group_tag'\n";
} else {
$group_tag_to_funnel_dataflow_rule{$group_tag} = $df_rule;
}
}
} # /for all templates
} # /for all heirs
} # /for all branch_tags
# -------------------------------------------- / DFR parser cloned from HiveGeneric_conf
$runnable_object->input_job($job);
$runnable_object->life_cycle();
......
......@@ -78,7 +78,6 @@ use POSIX;
use Bio::EnsEMBL::Hive::Analysis;
use Bio::EnsEMBL::Hive::AnalysisStats;
use Bio::EnsEMBL::Hive::Limiter;
use Bio::EnsEMBL::Hive::DBSQL::AccumulatorAdaptor;
use Bio::EnsEMBL::Hive::DBSQL::AnalysisJobAdaptor;
use Bio::EnsEMBL::Hive::DBSQL::AnalysisStatsAdaptor;
use Bio::EnsEMBL::Hive::DBSQL::DataflowRuleAdaptor;
......@@ -572,7 +571,7 @@ sub run {
# have runnable clean up any global/process files/data it may have created
if($self->perform_cleanup) {