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   if (is_exception $@) {
  28     weaken(
  29       $guard->{existing_exception_ref} = (ref($@) eq '') ? \$@ : $@
  30     );
  31   }
  32
  33   $storage->txn_begin;
  34
  35   weaken( $guard->{dbh} = $storage->_dbh );
  36
  37   bless $guard, ref $class || $class;
  38
  39   $guard;
  40 }
  41
  42 sub commit {
  43   my $self = shift;
  44
  45   $self->{storage}->throw_exception("Refusing to execute multiple commits on scope guard $self")
  46     if $self->{inactivated};
  47
  48   $self->{storage}->txn_commit;
  49   $self->{inactivated} = 1;
  50 }
  51
  52 sub DESTROY {
  53   return if &detected_reinvoked_destructor;
  54
  55   my $self = shift;
  56
  57   return if $self->{inactivated};
  58
  59   # if our dbh is not ours anymore, the $dbh weakref will go undef
  60   $self->{storage}->_verify_pid unless DBIx::Class::_ENV_::BROKEN_FORK;
  61   return unless $self->{dbh};
  62
  63   my $exception = $@ if (
  64     is_exception $@
  65       and
  66     (
  67       ! defined $self->{existing_exception_ref}
  68         or
  69       refaddr( ref($@) eq '' ? \$@ : $@ ) != refaddr($self->{existing_exception_ref})
  70     )
  71   );
  72
  73   {
  74     local $@;
  75
  76     carp 'A DBIx::Class::Storage::TxnScopeGuard went out of scope without explicit commit or error. Rolling back.'
  77       unless defined $exception;
  78
  79     my $rollback_exception;
  80     # do minimal connectivity check due to weird shit like
  81     # https://rt.cpan.org/Public/Bug/Display.html?id=62370
  82     try { $self->{storage}->_seems_connected && $self->{storage}->txn_rollback }
  83     catch { $rollback_exception = shift };
  84
  85     if ( $rollback_exception and (
  86       ! defined blessed $rollback_exception
  87           or
  88       ! $rollback_exception->isa('DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION')
  89     ) ) {
  90       # append our text - THIS IS A TEMPORARY FIXUP!
  91       # a real stackable exception object is in the works
  92       if (ref $exception eq 'DBIx::Class::Exception') {
  93         $exception->{msg} = "Transaction aborted: $exception->{msg} "
  94           ."Rollback failed: ${rollback_exception}";
  95       }
  96       elsif ($exception) {
  97         $exception = "Transaction aborted: ${exception} "
  98           ."Rollback failed: ${rollback_exception}";
  99       }
 100       else {
 101         carp (join ' ',
 102           "********************* ROLLBACK FAILED!!! ********************",
 103           "\nA rollback operation failed after the guard went out of scope.",
 104           'This is potentially a disastrous situation, check your data for',
 105           "consistency: $rollback_exception"
 106         );
 107       }
 108     }
 109   }
 110
 111   $@ = $exception;
 112 }
 113
 114 1;
 115
 116 __END__
 117
 118 =head1 NAME
 119
 120 DBIx::Class::Storage::TxnScopeGuard - Scope-based transaction handling
 121
 122 =head1 SYNOPSIS
 123
 124  sub foo {
 125    my ($self, $schema) = @_;
 126
 127    my $guard = $schema->txn_scope_guard;
 128
 129    # Multiple database operations here
 130
 131    $guard->commit;
 132  }
 133
 134 =head1 DESCRIPTION
 135
 136 An object that behaves much like L<Scope::Guard>, but hardcoded to do the
 137 right thing with transactions in DBIx::Class.
 138
 139 =head1 METHODS
 140
 141 =head2 new
 142
 143 Creating an instance of this class will start a new transaction (by
 144 implicitly calling L<DBIx::Class::Storage/txn_begin>. Expects a
 145 L<DBIx::Class::Storage> object as its only argument.
 146
 147 =head2 commit
 148
 149 Commit the transaction, and stop guarding the scope. If this method is not
 150 called and this object goes out of scope (e.g. an exception is thrown) then
 151 the transaction is rolled back, via L<DBIx::Class::Storage/txn_rollback>
 152
 153 =cut
 154
 155 =head1 SEE ALSO
 156
 157 L<DBIx::Class::Schema/txn_scope_guard>.
 158
 159 L<Scope::Guard> by chocolateboy (inspiration for this module)
 160
 161 =head1 FURTHER QUESTIONS?
 162
 163 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
 164
 165 =head1 COPYRIGHT AND LICENSE
 166
 167 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
 168 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
 169 redistribute it and/or modify it under the same terms as the
 170 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.