Services/Transaction/Castle.Services.Transaction/DefaultTransactionManager.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.ComponentModel;
  19         using Castle.Core.Logging;
  20
  21         /// <summary>
  22         /// TODO: Ensure this class is thread-safe
  23         /// </summary>
  24         public class DefaultTransactionManager : MarshalByRefObject, ITransactionManager
  25         {
  26                 private static readonly object TransactionCreatedEvent = new object();
  27                 private static readonly object TransactionCommittedEvent = new object();
  28                 private static readonly object TransactionRolledbackEvent = new object();
  29                 private static readonly object TransactionFailedEvent = new object();
  30                 private static readonly object TransactionDisposedEvent = new object();
  31                 private static readonly object ChildTransactionCreatedEvent = new object();
  32
  33                 private EventHandlerList events = new EventHandlerList();
  34                 private ILogger logger = NullLogger.Instance;
  35                 private IActivityManager activityManager;
  36
  37                 /// <summary>
  38                 /// Initializes a new instance of the <see cref="DefaultTransactionManager"/> class.
  39                 /// </summary>
  40                 public DefaultTransactionManager() : this(new CallContextActivityManager())
  41                 {
  42                 }
  43
  44                 /// <summary>
  45                 /// Initializes a new instance of the <see cref="DefaultTransactionManager"/> class.
  46                 /// </summary>
  47                 /// <param name="activityManager">The activity manager.</param>
  48                 public DefaultTransactionManager(IActivityManager activityManager)
  49                 {
  50                         this.activityManager = activityManager;
  51                 }
  52
  53                 /// <summary>
  54                 /// Gets or sets the activity manager.
  55                 /// </summary>
  56                 /// <value>The activity manager.</value>
  57                 public IActivityManager ActivityManager
  58                 {
  59                         get { return activityManager; }
  60                         set { activityManager = value; }
  61                 }
  62
  63                 /// <summary>
  64                 /// Gets or sets the logger.
  65                 /// </summary>
  66                 /// <value>The logger.</value>
  67                 public ILogger Logger
  68                 {
  69                         get { return logger; }
  70                         set { logger = value; }
  71                 }
  72
  73                 #region MarshalByRefObject
  74
  75                 public override object InitializeLifetimeService()
  76                 {
  77                         return null;
  78                 }
  79
  80                 #endregion
  81
  82                 #region ITransactionManager Members
  83
  84                 /// <summary>
  85                 /// Creates a transaction.
  86                 /// </summary>
  87                 /// <param name="transactionMode">The transaction mode.</param>
  88                 /// <param name="isolationMode">The isolation mode.</param>
  89                 /// <returns></returns>
  90                 public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode)
  91                 {
  92                         return CreateTransaction(transactionMode, isolationMode, false);
  93                 }
  94
  95                 /// <summary>
  96                 /// Creates a transaction.
  97                 /// </summary>
  98                 /// <param name="transactionMode">The transaction mode.</param>
  99                 /// <param name="isolationMode">The isolation mode.</param>
 100                 /// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param>
 101                 /// <returns></returns>
 102                 public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
 103                 {
 104                         if (transactionMode == TransactionMode.Unspecified)
 105                         {
 106                                 transactionMode = ObtainDefaultTransactionMode(transactionMode);
 107                         }
 108
 109                         CheckNotSupportedTransaction(transactionMode);
 110
 111                         if (CurrentTransaction == null &&
 112                             (transactionMode == TransactionMode.Supported ||
 113                              transactionMode == TransactionMode.NotSupported))
 114                         {
 115                                 return null;
 116                         }
 117
 118                         AbstractTransaction transaction = null;
 119
 120                         if (CurrentTransaction != null)
 121                         {
 122                                 if (transactionMode == TransactionMode.Requires || transactionMode == TransactionMode.Supported)
 123                                 {
 124                                         transaction = ((StandardTransaction) CurrentTransaction).CreateChildTransaction();
 125
 126                                         RaiseChildTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction);
 127
 128                                         logger.DebugFormat("Child Transaction {0} created", transaction.GetHashCode());
 129                                 }
 130                         }
 131
 132                         if (transaction == null)
 133                         {
 134                                 transaction = InstantiateTransaction(transactionMode, isolationMode, distributedTransaction);
 135
 136                                 if (distributedTransaction)
 137                                 {
 138 #if MONO
 139                                         throw new TransactionException("Distributed transactions are not supported on Mono");
 140 #else
 141                                         transaction.Enlist(new TransactionScopeResourceAdapter(transactionMode, isolationMode));
 142 #endif
 143                                 }
 144
 145                                 RaiseTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction);
 146
 147                                 logger.DebugFormat("Transaction {0} created", transaction.GetHashCode());
 148                         }
 149
 150                         transaction.Logger = logger.CreateChildLogger(transaction.GetType().FullName);
 151
 152                         activityManager.CurrentActivity.Push(transaction);
 153
 154                         return transaction;
 155                 }
 156
 157                 /// <summary>
 158                 /// Factory method for creating a transaction.
 159                 /// </summary>
 160                 /// <param name="transactionMode">The transaction mode.</param>
 161                 /// <param name="isolationMode">The isolation mode.</param>
 162                 /// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param>
 163                 /// <returns>A transaction</returns>
 164                 protected virtual AbstractTransaction InstantiateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
 165                 {
 166                         return new StandardTransaction(
 167                                 new TransactionDelegate(RaiseTransactionCommitted),
 168                                 new TransactionDelegate(RaiseTransactionRolledback),
 169                                 new TransactionErrorDelegate(RaiseTransactionFailed),
 170                                 transactionMode, isolationMode, distributedTransaction);
 171                 }
 172
 173                 public virtual ITransaction CurrentTransaction
 174                 {
 175                         get { return activityManager.CurrentActivity.CurrentTransaction; }
 176                 }
 177
 178                 #region events
 179
 180                 public event TransactionCreationInfoDelegate TransactionCreated
 181                 {
 182                         add { events.AddHandler(TransactionCreatedEvent, value); }
 183                         remove { events.RemoveHandler(TransactionCreatedEvent, value); }
 184                 }
 185
 186                 public event TransactionCreationInfoDelegate ChildTransactionCreated
 187                 {
 188                         add { events.AddHandler(ChildTransactionCreatedEvent, value); }
 189                         remove { events.RemoveHandler(ChildTransactionCreatedEvent, value); }
 190                 }
 191
 192                 public event TransactionDelegate TransactionCommitted
 193                 {
 194                         add { events.AddHandler(TransactionCommittedEvent, value); }
 195                         remove { events.RemoveHandler(TransactionCommittedEvent, value); }
 196                 }
 197
 198                 public event TransactionDelegate TransactionRolledback
 199                 {
 200                         add { events.AddHandler(TransactionRolledbackEvent, value); }
 201                         remove { events.RemoveHandler(TransactionRolledbackEvent, value); }
 202                 }
 203
 204                 public event TransactionErrorDelegate TransactionFailed
 205                 {
 206                         add { events.AddHandler(TransactionFailedEvent, value); }
 207                         remove { events.RemoveHandler(TransactionFailedEvent, value); }
 208                 }
 209
 210                 public event TransactionDelegate TransactionDisposed
 211                 {
 212                         add { events.AddHandler(TransactionDisposedEvent, value); }
 213                         remove { events.RemoveHandler(TransactionDisposedEvent, value); }
 214                 }
 215
 216                 protected void RaiseTransactionCreated(ITransaction transaction, TransactionMode transactionMode,
 217                                                        IsolationMode isolationMode, bool distributedTransaction)
 218                 {
 219                         TransactionCreationInfoDelegate eventDelegate = (TransactionCreationInfoDelegate) events[TransactionCreatedEvent];
 220
 221                         if (eventDelegate != null)
 222                         {
 223                                 eventDelegate(transaction, transactionMode, isolationMode, distributedTransaction);
 224                         }
 225                 }
 226
 227                 protected void RaiseChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode,
 228                                                                                                         IsolationMode isolationMode, bool distributedTransaction)
 229                 {
 230                         TransactionCreationInfoDelegate eventDelegate =
 231                                 (TransactionCreationInfoDelegate) events[ChildTransactionCreatedEvent];
 232
 233                         if (eventDelegate != null)
 234                         {
 235                                 eventDelegate(transaction, transactionMode, isolationMode, distributedTransaction);
 236                         }
 237                 }
 238
 239                 protected void RaiseTransactionFailed(ITransaction transaction, TransactionException exception)
 240                 {
 241                         TransactionErrorDelegate eventDelegate = (TransactionErrorDelegate)events[TransactionFailedEvent];
 242
 243                         if (eventDelegate != null)
 244                         {
 245                                 eventDelegate(transaction, exception);
 246                         }
 247                 }
 248
 249                 protected void RaiseTransactionDisposed(ITransaction transaction)
 250                 {
 251                         TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionDisposedEvent];
 252
 253                         if (eventDelegate != null)
 254                         {
 255                                 eventDelegate(transaction);
 256                         }
 257                 }
 258
 259                 protected void RaiseTransactionCommitted(ITransaction transaction)
 260                 {
 261                         TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionCommittedEvent];
 262
 263                         if (eventDelegate != null)
 264                         {
 265                                 eventDelegate(transaction);
 266                         }
 267                 }
 268
 269                 protected void RaiseTransactionRolledback(ITransaction transaction)
 270                 {
 271                         TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionRolledbackEvent];
 272
 273                         if (eventDelegate != null)
 274                         {
 275                                 eventDelegate(transaction);
 276                         }
 277                 }
 278
 279                 #endregion
 280
 281                 public virtual void Dispose(ITransaction transaction)
 282                 {
 283                         if (transaction == null)
 284                         {
 285                                 throw new ArgumentNullException("transaction", "Tried to dispose a null transaction");
 286                         }
 287
 288                         if (CurrentTransaction != transaction)
 289                         {
 290                                 throw new ArgumentException("transaction",
 291                                                             "Tried to dispose a transaction that is not on the current active transaction");
 292                         }
 293
 294                         activityManager.CurrentActivity.Pop();
 295
 296                         if (transaction is IDisposable)
 297                         {
 298                                 (transaction as IDisposable).Dispose();
 299                         }
 300
 301                         RaiseTransactionDisposed(transaction);
 302
 303                         logger.DebugFormat("Transaction {0} disposed successfully", transaction.GetHashCode());
 304                 }
 305
 306                 #endregion
 307
 308                 protected virtual TransactionMode ObtainDefaultTransactionMode(TransactionMode transactionMode)
 309                 {
 310                         return TransactionMode.Requires;
 311                 }
 312
 313                 private void CheckNotSupportedTransaction(TransactionMode transactionMode)
 314                 {
 315                         if (transactionMode == TransactionMode.NotSupported &&
 316                             CurrentTransaction != null &&
 317                             CurrentTransaction.Status == TransactionStatus.Active)
 318                         {
 319                                 String message = "There is a transaction active and the transaction mode " +
 320                                                  "explicit says that no transaction is supported for this context";
 321
 322                                 logger.Error(message);
 323
 324                                 throw new TransactionException(message);
 325                         }
 326                 }
 327         }
 328 }