lib/DBIx/Class/Storage/TxnScopeGuard.pm

   1 package DBIx::Class::Storage::TxnScopeGuard;
   2
   3 use strict;
   4 use warnings;
   5 use Try::Tiny;
   6 use Scalar::Util qw(weaken blessed refaddr);
   7 use DBIx::Class;
   8 use DBIx::Class::_Util qw(is_exception detected_reinvoked_destructor);
   9 use DBIx::Class::Carp;
  10 use namespace::clean;
  11
  12 sub new {
  13   my ($class, $storage) = @_;
  14
  15   my $guard = {
  16     inactivated => 0,
  17     storage => $storage,
  18   };
  19
  20   # we are starting with an already set $@ - in order for things to work we need to
  21   # be able to recognize it upon destruction - store its weakref
  22   # recording it before doing the txn_begin stuff
  23   #
  24   # FIXME FRAGILE - any eval that fails but *does not* rethrow between here
  25   # and the unwind will trample over $@ and invalidate the entire mechanism
  26   # There got to be a saner way of doing this...
  27   #
  28   # Deliberately *NOT* using is_exception - if someone left a misbehaving
  29   # antipattern value in $@, it's not our business to whine about it
  30   if( defined $@ and length $@ ) {
  31     weaken(
  32       $guard->{existing_exception_ref} = (length ref $@) ? $@ : \$@
  33     );
  34   }
  35
  36   $storage->txn_begin;
  37
  38   weaken( $guard->{dbh} = $storage->_dbh );
  39
  40   bless $guard, ref $class || $class;
  41
  42   $guard;
  43 }
  44
  45 sub commit {
  46   my $self = shift;
  47
  48   $self->{storage}->throw_exception("Refusing to execute multiple commits on scope guard $self")
  49     if $self->{inactivated};
  50
  51   # FIXME - this assumption may be premature: a commit may fail and a rollback
  52   # *still* be necessary. Currently I am not aware of such scenarious, but I
  53   # also know the deferred constraint handling is *severely* undertested.
  54   # Making the change of "fire txn and never come back to this" in order to
  55   # address RT#107159, but this *MUST* be reevaluated later.
  56   $self->{inactivated} = 1;
  57   $self->{storage}->txn_commit;
  58 }
  59
  60 sub DESTROY {
  61   return if &detected_reinvoked_destructor;
  62
  63   my $self = shift;
  64
  65   return if $self->{inactivated};
  66
  67   # if our dbh is not ours anymore, the $dbh weakref will go undef
  68   $self->{storage}->_verify_pid unless DBIx::Class::_ENV_::BROKEN_FORK;
  69   return unless $self->{dbh};
  70
  71   my $exception = $@ if (
  72     is_exception $@
  73       and
  74     (
  75       ! defined $self->{existing_exception_ref}
  76         or
  77       refaddr( (length ref $@) ? $@ : \$@ ) != refaddr($self->{existing_exception_ref})
  78     )
  79   );
  80
  81   {
  82     local $@;
  83
  84     carp 'A DBIx::Class::Storage::TxnScopeGuard went out of scope without explicit commit or error. Rolling back.'
  85       unless defined $exception;
  86
  87     my $rollback_exception;
  88     # do minimal connectivity check due to weird shit like
  89     # https://rt.cpan.org/Public/Bug/Display.html?id=62370
  90     try { $self->{storage}->_seems_connected && $self->{storage}->txn_rollback }
  91     catch { $rollback_exception = shift };
  92
  93     if ( $rollback_exception and (
  94       ! defined blessed $rollback_exception
  95           or
  96       ! $rollback_exception->isa('DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION')
  97     ) ) {
  98       # append our text - THIS IS A TEMPORARY FIXUP!
  99       # a real stackable exception object is in the works
 100       if (ref $exception eq 'DBIx::Class::Exception') {
 101         $exception->{msg} = "Transaction aborted: $exception->{msg} "
 102           ."Rollback failed: ${rollback_exception}";
 103       }
 104       elsif ($exception) {
 105         $exception = "Transaction aborted: ${exception} "
 106           ."Rollback failed: ${rollback_exception}";
 107       }
 108       else {
 109         carp (join ' ',
 110           "********************* ROLLBACK FAILED!!! ********************",
 111           "\nA rollback operation failed after the guard went out of scope.",
 112           'This is potentially a disastrous situation, check your data for',
 113           "consistency: $rollback_exception"
 114         );
 115       }
 116     }
 117   }
 118
 119   $@ = $exception;
 120 }
 121
 122 1;
 123
 124 __END__
 125
 126 =head1 NAME
 127
 128 DBIx::Class::Storage::TxnScopeGuard - Scope-based transaction handling
 129
 130 =head1 SYNOPSIS
 131
 132  sub foo {
 133    my ($self, $schema) = @_;
 134
 135    my $guard = $schema->txn_scope_guard;
 136
 137    # Multiple database operations here
 138
 139    $guard->commit;
 140  }
 141
 142 =head1 DESCRIPTION
 143
 144 An object that behaves much like L<Scope::Guard>, but hardcoded to do the
 145 right thing with transactions in DBIx::Class.
 146
 147 =head1 METHODS
 148
 149 =head2 new
 150
 151 Creating an instance of this class will start a new transaction (by
 152 implicitly calling L<DBIx::Class::Storage/txn_begin>. Expects a
 153 L<DBIx::Class::Storage> object as its only argument.
 154
 155 =head2 commit
 156
 157 Commit the transaction, and stop guarding the scope. If this method is not
 158 called and this object goes out of scope (e.g. an exception is thrown) then
 159 the transaction is rolled back, via L<DBIx::Class::Storage/txn_rollback>
 160
 161 =cut
 162
 163 =head1 SEE ALSO
 164
 165 L<DBIx::Class::Schema/txn_scope_guard>.
 166
 167 L<Scope::Guard> by chocolateboy (inspiration for this module)
 168
 169 =head1 FURTHER QUESTIONS?
 170
 171 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
 172
 173 =head1 COPYRIGHT AND LICENSE
 174
 175 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
 176 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
 177 redistribute it and/or modify it under the same terms as the
 178 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.