Services/Transaction/Castle.Services.Transaction/StandardTransaction.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Services.Transaction
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         /// <summary>
  21         /// Implements a transaction root.
  22         /// </summary>
  23         public class StandardTransaction : AbstractTransaction
  24         {
  25                 private readonly TransactionDelegate onTransactionCommitted;
  26                 private readonly TransactionDelegate onTransactionRolledback;
  27                 private readonly TransactionErrorDelegate onTransactionFailed;
  28
  29                 private IList children = ArrayList.Synchronized( new ArrayList() );
  30                 private bool rollbackOnly;
  31
  32                 protected StandardTransaction()
  33                 {
  34                 }
  35
  36                 public StandardTransaction(TransactionDelegate onTransactionCommitted, TransactionDelegate onTransactionRolledback,
  37                         TransactionErrorDelegate onTransactionFailed, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) :
  38                         this(transactionMode, isolationMode, distributedTransaction)
  39                 {
  40                         this.onTransactionCommitted = onTransactionCommitted;
  41                         this.onTransactionRolledback = onTransactionRolledback;
  42                         this.onTransactionFailed = onTransactionFailed;
  43                 }
  44
  45                 public StandardTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) :
  46                         base(transactionMode, isolationMode, distributedTransaction)
  47                 {
  48                 }
  49
  50                 public StandardTransaction CreateChildTransaction()
  51                 {
  52                         ChildTransaction child = new ChildTransaction(this);
  53
  54                         children.Add(child);
  55
  56                         return child;
  57                 }
  58
  59                 public override bool IsChildTransaction
  60                 {
  61                         get { return false; }
  62                 }
  63
  64                 public override void Commit()
  65                 {
  66                         if (rollbackOnly)
  67                         {
  68                                 throw new TransactionException("Can't commit as transaction was marked as 'rollback only'");
  69                         }
  70
  71                         try
  72                         {
  73                                 base.Commit();
  74                         }
  75                         catch (TransactionException transactionError)
  76                         {
  77                                 if (onTransactionFailed != null)
  78                                 {
  79                                         try
  80                                         {
  81                                                 onTransactionFailed(this, transactionError);
  82                                         }
  83                                         catch (Exception e)
  84                                         {
  85                                                 // Log exception & swallow it
  86                                                 Logger.Warn("An error occured while notifying caller about transaction commit failure.", e);
  87                                         }
  88                                 }
  89                                 throw;
  90                         }
  91
  92                         if (onTransactionCommitted != null) onTransactionCommitted(this);
  93                 }
  94
  95                 public override void Rollback()
  96                 {
  97                         try
  98                         {
  99                                 base.Rollback();
 100                         }
 101                         catch (TransactionException transactionError)
 102                         {
 103                                 if (onTransactionFailed != null)
 104                                 {
 105                                         try
 106                                         {
 107                                                 onTransactionFailed(this, transactionError);
 108                                         }
 109                                         catch (Exception e)
 110                                         {
 111                                                 // Log exception & swallow it
 112                                                 Logger.Warn("An error occured while notifying caller about transaction rollback failure.", e);
 113                                         }
 114                                 }
 115                                 throw;
 116                         }
 117
 118                         if (onTransactionRolledback != null) onTransactionRolledback(this);
 119                 }
 120
 121                 public override void SetRollbackOnly()
 122                 {
 123                         rollbackOnly = true;
 124                 }
 125
 126                 public override bool IsRollbackOnlySet
 127                 {
 128                         get { return rollbackOnly; }
 129                 }
 130         }
 131
 132         /// <summary>
 133         /// Emulates a standalone transaction but in fact it
 134         /// just propages a transaction.
 135         /// </summary>
 136         public class ChildTransaction : StandardTransaction
 137         {
 138                 private StandardTransaction _parent;
 139
 140                 public ChildTransaction(StandardTransaction parent) :
 141                         base(parent.TransactionMode, parent.IsolationMode, parent.DistributedTransaction)
 142                 {
 143                         _parent = parent;
 144                 }
 145
 146                 public override void Enlist(IResource resource)
 147                 {
 148                         _parent.Enlist(resource);
 149                 }
 150
 151                 public override void Begin()
 152                 {
 153                         // Ignored
 154                 }
 155
 156                 public override void Rollback()
 157                 {
 158                         // Vote as rollback
 159
 160                         _parent.SetRollbackOnly();
 161                 }
 162
 163                 public override void Commit()
 164                 {
 165                         // Vote as commit
 166                 }
 167
 168                 public override void SetRollbackOnly()
 169                 {
 170                         Rollback();
 171                 }
 172
 173                 public override void RegisterSynchronization(ISynchronization synchronization)
 174                 {
 175                         _parent.RegisterSynchronization(synchronization);
 176                 }
 177
 178                 public override IDictionary Context
 179                 {
 180                         get { return _parent.Context; }
 181                 }
 182
 183                 public override bool IsChildTransaction
 184                 {
 185                         get { return true; }
 186                 }
 187
 188                 public override bool IsRollbackOnlySet
 189                 {
 190                         get { return _parent.IsRollbackOnlySet; }
 191                 }
 192         }
 193 }