public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { // prevent commands in main thread to run concurrently Driver driver = connection.driver; lock (driver) { rollbackThreadId = Thread.CurrentThread.ManagedThreadId; while (connection.Reader != null) { // wait for reader to finish. Maybe we should not wait // forever and cancel it after some time? System.Threading.Thread.Sleep(100); } simpleTransaction.Rollback(); singlePhaseEnlistment.Aborted(); DriverTransactionManager.RemoveDriverInTransaction(baseTransaction); driver.CurrentTransaction = null; if (connection.State == ConnectionState.Closed) { connection.CloseFully(); } rollbackThreadId = 0; } }
/// <summary> /// Enlists in the specified transaction. /// </summary> /// <param name="transaction"> /// A reference to an existing <see cref="System.Transactions.Transaction"/> in which to enlist. /// </param> public override void EnlistTransaction(Transaction transaction) { // enlisting in the null transaction is a noop if (transaction == null) { return; } // guard against trying to enlist in more than one transaction if (driver.CurrentTransaction != null) { if (driver.CurrentTransaction.BaseTransaction == transaction) { return; } Throw(new MySqlException("Already enlisted")); } // now see if we need to swap out drivers. We would need to do this since // we have to make sure all ops for a given transaction are done on the // same physical connection. Driver existingDriver = DriverTransactionManager.GetDriverInTransaction(transaction); if (existingDriver != null) { // we can't allow more than one driver to contribute to the same connection if (existingDriver.IsInActiveUse) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } // there is an existing driver and it's not being currently used. // now we need to see if it is using the same connection string string text1 = existingDriver.Settings.ConnectionString; string text2 = Settings.ConnectionString; if (String.Compare(text1, text2, true) != 0) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } // close existing driver // set this new driver as our existing driver CloseFully(); driver = existingDriver; } if (driver.CurrentTransaction == null) { MySqlPromotableTransaction t = new MySqlPromotableTransaction(this, transaction); if (!transaction.EnlistPromotableSinglePhase(t)) { Throw(new NotSupportedException(Resources.DistributedTxnNotSupported)); } driver.CurrentTransaction = t; DriverTransactionManager.SetDriverInTransaction(driver); driver.IsInActiveUse = true; } }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { simpleTransaction.Commit(); singlePhaseEnlistment.Committed(); DriverTransactionManager.RemoveDriverInTransaction(baseTransaction); connection.driver.CurrentTransaction = null; if (connection.State == ConnectionState.Closed) { connection.CloseFully(); } }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } #if !CF && !RT // start up our interceptors exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); #endif SetState(ConnectionState.Connecting, true); AssertPermissions(); #if !CF && !RT // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (Settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } } #endif try { MySqlConnectionStringBuilder currentSettings = Settings; #if !CF // Load balancing if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); } else { currentSettings = driver.Settings; } } #endif if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) { MySqlTrace.LogWarning(ServerThread, "You are using old syntax that will be removed in future versions"); } SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (Settings.Database != null && Settings.Database != String.Empty) { ChangeDatabase(Settings.Database); } } // setup our schema provider schemaProvider = new ISSchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF && !RT if (Transaction.Current != null && Settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }