lib/Test/Valgrind/Session.pm

   1 package Test::Valgrind::Session;
   2
   3 use strict;
   4 use warnings;
   5
   6 =head1 NAME
   7
   8 Test::Valgrind::Session - Test::Valgrind session object.
   9
  10 =head1 VERSION
  11
  12 Version 1.15
  13
  14 =cut
  15
  16 our $VERSION = '1.15';
  17
  18 =head1 DESCRIPTION
  19
  20 This class supervises the execution of the C<valgrind> process.
  21 It also acts as a dispatcher between the different components.
  22
  23 =cut
  24
  25 use File::Spec   ();
  26 use Scalar::Util ();
  27
  28 use Fcntl (); # F_SETFD
  29 use POSIX (); # SIGKILL
  30
  31 use version ();
  32
  33 use base qw<Test::Valgrind::Carp>;
  34
  35 =head1 METHODS
  36
  37 =head2 C<new>
  38
  39     my $tvs = Test::Valgrind::Session->new(
  40      search_dirs    => \@search_dirs,
  41      valgrind       => $valgrind,  # One candidate
  42      valgrind       => \@valgrind, # Several candidates
  43      min_version    => $min_version,
  44      regen_def_supp => $regen_def_supp,
  45      no_def_supp    => $no_def_supp,
  46      allow_no_supp  => $allow_no_supp,
  47      extra_supps    => \@extra_supps,
  48     );
  49
  50 The package constructor, which takes several options :
  51
  52 =over 4
  53
  54 =item *
  55
  56 All the directories from C<@search_dirs> will have F<valgrind> appended to create a list of candidates for the C<valgrind> executable.
  57
  58 Defaults to the current C<PATH> environment variable.
  59
  60 =item *
  61
  62 If a simple scalar C<$valgrind> is passed as the value to C<'valgrind'>, it will be the only candidate.
  63 C<@search_dirs> will then be ignored.
  64
  65 If an array refernce C<\@valgrind> is passed, its values will be I<prepended> to the list of the candidates resulting from C<@search_dirs>.
  66
  67 =item *
  68
  69 C<$min_version> specifies the minimal C<valgrind> version required.
  70 The constructor will croak if it's not able to find an adequate C<valgrind> from the supplied candidates list and search path.
  71
  72 Defaults to none.
  73
  74 =item *
  75
  76 If C<$regen_def_supp> is true, the default suppression file associated with the tool and the command will be forcefully regenerated.
  77
  78 Defaults to false.
  79
  80 =item *
  81
  82 If C<$no_def_supp> is true, C<valgrind> won't read the default suppression file associated with the tool and the command.
  83
  84 Defaults to false.
  85
  86 =item *
  87
  88 If C<$allow_no_supp> is true, the command will always be run into C<valgrind> even if no appropriate suppression file is available.
  89
  90 Defaults to false.
  91
  92 =item *
  93
  94 C<$extra_supps> is a reference to an array of optional suppression files that will be passed to C<valgrind>.
  95
  96 Defaults to none.
  97
  98 =back
  99
 100 =cut
 101
 102 sub new {
 103  my $class = shift;
 104  $class = ref($class) || $class;
 105
 106  my %args = @_;
 107
 108  my @paths;
 109  my $vg = delete $args{valgrind};
 110  if (defined $vg and not ref $vg) {
 111   @paths = ($vg);
 112  } else {
 113   push @paths, @$vg if $vg and ref $vg eq 'ARRAY';
 114   my $dirs = delete $args{search_dirs};
 115   $dirs = [ File::Spec->path ] unless $dirs;
 116   push @paths, map File::Spec->catfile($_, 'valgrind'), @$dirs
 117                                                         if ref $dirs eq 'ARRAY';
 118  }
 119  $class->_croak('Empty valgrind candidates list') unless @paths;
 120
 121  my $min_version = delete $args{min_version};
 122  defined and not ref and $_ = version->new($_) for $min_version;
 123
 124  my ($valgrind, $version);
 125  for (@paths) {
 126   next unless -x;
 127   my $ver = qx/$_ --version/;
 128   if ($ver =~ /^valgrind-(\d+(\.\d+)*)/) {
 129    if ($min_version) {
 130     $version = version->new($1);
 131     next if $version < $min_version;
 132    } else {
 133     $version = $1;
 134    }
 135    $valgrind = $_;
 136    last;
 137   }
 138  }
 139  $class->_croak('No appropriate valgrind executable could be found')
 140                                                        unless defined $valgrind;
 141
 142  my $extra_supps = delete $args{extra_supps};
 143  $extra_supps    = [ ] unless $extra_supps and ref $extra_supps eq 'ARRAY';
 144  @$extra_supps   = grep { defined && -f $_ && -r _ } @$extra_supps;
 145
 146  bless {
 147   valgrind       => $valgrind,
 148   version        => $version,
 149   regen_def_supp => delete($args{regen_def_supp}),
 150   no_def_supp    => delete($args{no_def_supp}),
 151   allow_no_supp  => delete($args{allow_no_supp}),
 152   extra_supps    => $extra_supps,
 153  }, $class;
 154 }
 155
 156 =head2 C<valgrind>
 157
 158     my $valgrind_path = $tvs->valgrind;
 159
 160 The path to the selected C<valgrind> executable.
 161
 162 =head2 C<version>
 163
 164     my $valgrind_version = $tvs->version;
 165
 166 The L<version> object associated to the selected C<valgrind>.
 167
 168 =cut
 169
 170 sub version {
 171  my ($self) = @_;
 172
 173  my $version = $self->{version};
 174  $self->{version} = $version = version->new($version) unless ref $version;
 175
 176  return $version;
 177 }
 178
 179 =head2 C<regen_def_supp>
 180
 181     my $regen_def_supp = $tvs->regen_def_supp;
 182
 183 Read-only accessor for the C<regen_def_supp> option.
 184
 185 =cut
 186
 187 =head2 C<no_def_supp>
 188
 189     my $no_def_supp = $tvs->no_def_supp;
 190
 191 Read-only accessor for the C<no_def_supp> option.
 192
 193 =head2 C<allow_no_supp>
 194
 195     my $allow_no_supp = $tvs->allow_no_supp;
 196
 197 Read-only accessor for the C<allow_no_supp> option.
 198
 199 =cut
 200
 201 eval "sub $_ { \$_[0]->{$_} }" for qw<
 202  valgrind
 203  regen_def_supp
 204  no_def_supp
 205  allow_no_supp
 206 >;
 207
 208 =head2 C<extra_supps>
 209
 210     my @extra_supps = $tvs->extra_supps;
 211
 212 Read-only accessor for the C<extra_supps> option.
 213
 214 =cut
 215
 216 sub extra_supps { @{$_[0]->{extra_supps} || []} }
 217
 218 =head2 C<run>
 219
 220     $tvs->run(
 221      action  => $action,
 222      tool    => $tool,
 223      command => $command,
 224     );
 225
 226 Runs the command C<$command> through C<valgrind> with the tool C<$tool>, which will report to the action C<$action>.
 227
 228 If the command is a L<Test::Valgrind::Command::Aggregate> object, the action and the tool will be initialized once before running all the aggregated commands.
 229
 230 =cut
 231
 232 sub run {
 233  my $self = shift;
 234
 235  my %args = @_;
 236
 237  $self->start(%args);
 238  my $guard = Test::Valgrind::Session::Guard->new(sub { $self->finish });
 239
 240  $self->_run($args{command});
 241 }
 242
 243 sub _run {
 244  my ($self, $cmd) = @_;
 245
 246  if ($cmd->isa('Test::Valgrind::Command::Aggregate')) {
 247   $self->_run($_) for $cmd->commands;
 248   return;
 249  }
 250
 251  $self->command($cmd);
 252
 253  $self->report($self->report_class->new_diag(
 254   'Using valgrind ' . $self->version . ' located at ' . $self->valgrind
 255  ));
 256
 257  my $env = $self->command->env($self);
 258
 259  my @supp_args;
 260  if ($self->do_suppressions) {
 261   push @supp_args, '--gen-suppressions=all';
 262  } else {
 263   if (!$self->no_def_supp) {
 264    my $def_supp = $self->def_supp_file;
 265    my $forced;
 266    if ($self->regen_def_supp and -e $def_supp) {
 267     1 while unlink $def_supp;
 268     $forced = 1;
 269    }
 270    if (defined $def_supp and not -e $def_supp) {
 271     $self->report($self->report_class->new_diag(
 272      'Generating suppressions' . ($forced ? ' (forced)' : '') . '...'
 273     ));
 274     require Test::Valgrind::Suppressions;
 275     Test::Valgrind::Suppressions->generate(
 276      tool    => $self->tool,
 277      command => $self->command,
 278      target  => $def_supp,
 279     );
 280     $self->_croak('Couldn\'t generate suppressions') unless -e $def_supp;
 281     $self->report($self->report_class->new_diag(
 282      "Suppressions for this perl stored in $def_supp"
 283     ));
 284    }
 285   }
 286   my @supp_files = grep {
 287    -e $_ and $self->command->check_suppressions_file($_)
 288   } $self->suppressions;
 289   if (@supp_files > 1) {
 290    my $files_list = join "\n", map "    $_", @supp_files;
 291    $self->report($self->report_class->new_diag(
 292     "Using suppressions from:\n$files_list"
 293    ));
 294   } elsif (@supp_files) {
 295    $self->report($self->report_class->new_diag(
 296     "Using suppressions from $supp_files[0]"
 297    ));
 298   } elsif ($self->allow_no_supp) {
 299    $self->report($self->report_class->new_diag("No suppressions used"));
 300   } else {
 301    $self->_croak("No compatible suppressions available");
 302   }
 303   @supp_args = map "--suppressions=$_", @supp_files;
 304  }
 305
 306  pipe my $vrdr, my $vwtr or $self->_croak("pipe(\$vrdr, \$vwtr): $!");
 307  {
 308   my $oldfh = select $vrdr;
 309   $|++;
 310   select $oldfh;
 311  }
 312
 313  my $pid = fork;
 314  $self->_croak("fork(): $!") unless defined $pid;
 315
 316  if ($pid == 0) {
 317   eval 'setpgrp 0, 0';
 318   close $vrdr or $self->_croak("close(\$vrdr): $!");
 319   fcntl $vwtr, Fcntl::F_SETFD(), 0
 320                               or $self->_croak("fcntl(\$vwtr, F_SETFD, 0): $!");
 321
 322   my @args = (
 323    $self->valgrind,
 324    $self->tool->args($self),
 325    @supp_args,
 326    $self->parser->args($self, $vwtr),
 327    $self->command->args($self),
 328   );
 329
 330 #  $self->report($self->report_class->new_diag("@args"));
 331
 332   exec { $args[0] } @args or $self->_croak("exec @args: $!");
 333  }
 334
 335  local $SIG{INT} = sub {
 336   kill -(POSIX::SIGKILL()) => $pid;
 337   waitpid $pid, 0;
 338   die 'interrupted';
 339  };
 340
 341  close $vwtr or $self->_croak("close(\$vwtr): $!");
 342
 343  $self->parser->parse($self, $vrdr);
 344
 345  $self->{exit_code} = (waitpid($pid, 0) == $pid) ? $? >> 8 : 255;
 346
 347  close $vrdr or $self->_croak("close(\$vrdr): $!");
 348
 349  return;
 350 }
 351
 352 sub Test::Valgrind::Session::Guard::new     { bless \($_[1]), $_[0] }
 353
 354 sub Test::Valgrind::Session::Guard::DESTROY { ${$_[0]}->() }
 355
 356 =head2 C<action>
 357
 358 Read-only accessor for the C<action> associated to the current run.
 359
 360 =head2 C<tool>
 361
 362 Read-only accessor for the C<tool> associated to the current run.
 363
 364 =head2 C<parser>
 365
 366 Read-only accessor for the C<parser> associated to the current tool.
 367
 368 =head2 C<command>
 369
 370 Read-only accessor for the C<command> associated to the current run.
 371
 372 =cut
 373
 374 my @members;
 375 BEGIN {
 376  @members = qw<action tool command parser>;
 377  for (@members) {
 378   eval "sub $_ { \@_ <= 1 ? \$_[0]->{$_} : (\$_[0]->{$_} = \$_[1]) }";
 379   die if $@;
 380  }
 381 }
 382
 383 =head2 C<do_suppressions>
 384
 385 Forwards to C<< ->action->do_suppressions >>.
 386
 387 =cut
 388
 389 sub do_suppressions { $_[0]->action->do_suppressions }
 390
 391 =head2 C<parser_class>
 392
 393 Calls C<< ->tool->parser_class >> with the current session object as the unique argument.
 394
 395 =cut
 396
 397 sub parser_class { $_[0]->tool->parser_class($_[0]) }
 398
 399 =head2 C<report_class>
 400
 401 Calls C<< ->tool->report_class >> with the current session object as the unique argument.
 402
 403 =cut
 404
 405 sub report_class { $_[0]->tool->report_class($_[0]) }
 406
 407 =head2 C<def_supp_file>
 408
 409 Returns an absolute path to the default suppression file associated to the current session.
 410
 411 C<undef> will be returned as soon as any of C<< ->command->suppressions_tag >> or C<< ->tool->suppressions_tag >> are also C<undef>.
 412 Otherwise, the file part of the name is builded by joining those two together, and the directory part is roughly F<< File::HomeDir->my_home / .perl / Test-Valgrind / suppressions / $VERSION >>.
 413
 414 =cut
 415
 416 sub def_supp_file {
 417  my ($self) = @_;
 418
 419  my $tool_tag = $self->tool->suppressions_tag($self);
 420  return unless defined $tool_tag;
 421
 422  my $cmd_tag = $self->command->suppressions_tag($self);
 423  return unless defined $cmd_tag;
 424
 425  require File::HomeDir; # So that it's not needed at configure time.
 426
 427  return File::Spec->catfile(
 428   File::HomeDir->my_home,
 429   '.perl',
 430   'Test-Valgrind',
 431   'suppressions',
 432   $VERSION,
 433   "$tool_tag-$cmd_tag.supp",
 434  );
 435 }
 436
 437 =head2 C<suppressions>
 438
 439     my @suppressions = $tvs->suppressions;
 440
 441 Returns the list of all the suppressions that will be passed to C<valgrind>.
 442 Honors L</no_def_supp> and L</extra_supps>.
 443
 444 =cut
 445
 446 sub suppressions {
 447  my ($self) = @_;
 448
 449  my @supps;
 450  unless ($self->no_def_supp) {
 451   my $def_supp = $self->def_supp_file;
 452   push @supps, $def_supp if defined $def_supp;
 453  }
 454  push @supps, $self->extra_supps;
 455
 456  return @supps;
 457 }
 458
 459 =head2 C<start>
 460
 461     $tvs->start(
 462      action  => $action,
 463      tool    => $tool,
 464      command => $command,
 465     );
 466
 467 Starts the action and tool associated to the current run.
 468 It's automatically called at the beginning of L</run>.
 469
 470 =cut
 471
 472 sub start {
 473  my $self = shift;
 474
 475  my %args = @_;
 476
 477  for (qw<action tool command>) {
 478   my $base = 'Test::Valgrind::' . ucfirst;
 479   my $value = $args{$_};
 480   $self->_croak("Invalid $_") unless Scalar::Util::blessed($value)
 481                                                          and $value->isa($base);
 482   $self->$_($args{$_})
 483  }
 484
 485  delete @{$self}{qw<last_status exit_code>};
 486
 487  $self->tool->start($self);
 488  $self->parser($self->parser_class->new)->start($self);
 489  $self->action->start($self);
 490
 491  return;
 492 }
 493
 494 =head2 C<abort>
 495
 496     $tvs->abort($msg);
 497
 498 Forwards to C<< ->action->abort >> after unshifting the session object to the argument list.
 499
 500 =cut
 501
 502 sub abort {
 503  my $self = shift;
 504
 505  $self->action->abort($self, @_);
 506 }
 507
 508 =head2 C<report>
 509
 510     $tvs->report($report);
 511
 512 Forwards to C<< ->action->report >> after unshifting the session object to the argument list.
 513
 514 =cut
 515
 516 sub report {
 517  my ($self, $report) = @_;
 518
 519  return unless defined $report;
 520
 521  for my $handler (qw<tool command>) {
 522   $report = $self->$handler->filter($self, $report);
 523   return unless defined $report;
 524  }
 525
 526  $self->action->report($self, $report);
 527 }
 528
 529 =head2 C<finish>
 530
 531     $tvs->finish;
 532
 533 Finishes the action and tool associated to the current run.
 534 It's automatically called at the end of L</run>.
 535
 536 =cut
 537
 538 sub finish {
 539  my ($self) = @_;
 540
 541  my $action = $self->action;
 542
 543  $action->finish($self);
 544  $self->parser->finish($self);
 545  $self->tool->finish($self);
 546
 547  my $status = $action->status($self);
 548  $self->{last_status} = defined $status ? $status : $self->{exit_code};
 549
 550  $self->$_(undef) for @members;
 551
 552  return;
 553 }
 554
 555 =head2 C<status>
 556
 557     my $status = $tvs->status;
 558
 559 Returns the status code of the last run of the session.
 560
 561 =cut
 562
 563 sub status { $_[0]->{last_status} }
 564
 565 =head1 SEE ALSO
 566
 567 L<Test::Valgrind>, L<Test::Valgrind::Action>, L<Test::Valgrind::Command>, L<Test::Valgrind::Tool>, L<Test::Valgrind::Parser>.
 568
 569 L<version>, L<File::HomeDir>.
 570
 571 =head1 AUTHOR
 572
 573 Vincent Pit, C<< <perl at profvince.com> >>, L<http://www.profvince.com>.
 574
 575 You can contact me by mail or on C<irc.perl.org> (vincent).
 576
 577 =head1 BUGS
 578
 579 Please report any bugs or feature requests to C<bug-test-valgrind at rt.cpan.org>, or through the web interface at L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Test-Valgrind>.
 580 I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
 581
 582 =head1 SUPPORT
 583
 584 You can find documentation for this module with the perldoc command.
 585
 586     perldoc Test::Valgrind::Session
 587
 588 =head1 COPYRIGHT & LICENSE
 589
 590 Copyright 2009,2010,2011,2013,2015 Vincent Pit, all rights reserved.
 591
 592 This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
 593
 594 =cut
 595
 596 1; # End of Test::Valgrind::Session