private static bool SqlCommandAsyncResultCallback(IAsyncResult result) { SqlWorkflowInstanceStoreAsyncResult asyncState = (SqlWorkflowInstanceStoreAsyncResult)result.AsyncState; Exception exception = null; bool flag = true; try { using (asyncState.sqlCommand) { using (SqlDataReader reader = SqlCommandAsyncResult.End(result)) { exception = asyncState.ProcessSqlResult(reader); } } } catch (Exception exception2) { if (Fx.IsFatal(exception2)) { throw; } Guid instanceId = (asyncState.InstancePersistenceContext != null) ? asyncState.InstancePersistenceContext.InstanceView.InstanceId : Guid.Empty; exception = new InstancePersistenceCommandException(asyncState.InstancePersistenceCommand.Name, instanceId, exception2); } if (exception is InstanceAlreadyLockedToOwnerException) { InstanceAlreadyLockedToOwnerException exception3 = (InstanceAlreadyLockedToOwnerException)exception; long instanceVersion = exception3.InstanceVersion; if (!asyncState.InstancePersistenceContext.InstanceView.IsBoundToInstance) { asyncState.InstancePersistenceContext.BindInstance(exception3.InstanceId); } IAsyncResult result3 = asyncState.InstancePersistenceContext.BeginBindReclaimedLock(instanceVersion, asyncState.TimeoutHelper.RemainingTime(), asyncState.PrepareAsyncCompletion(onBindReclaimed), asyncState); if (!asyncState.SyncContinue(result3)) { flag = false; } return(flag); } if (exception == null) { return(flag); } if (asyncState.sqlCommand.Connection != null) { asyncState.sqlCommand.Connection.Close(); } asyncState.TraceException(exception); throw FxTrace.Exception.AsError(exception); }
void StartOperation() { Guid instanceId = (this.InstancePersistenceContext != null) ? this.InstancePersistenceContext.InstanceView.InstanceId : Guid.Empty; Exception delayedException = null; try { this.sqlCommand = new SqlCommand(); this.GenerateSqlCommand(this.sqlCommand); this.sqlCommand.CommandText = this.GetSqlCommandText(); this.sqlCommand.CommandType = this.GetSqlCommandType(); StoreUtilities.TraceSqlCommand(this.sqlCommand, true); SqlCommandAsyncResult sqlCommandResult = new SqlCommandAsyncResult(this.sqlCommand, this.ConnectionString, (this.InstancePersistenceContext != null) ? this.InstancePersistenceContext.EventTraceActivity : null, this.DependentTransaction, this.TimeoutHelper.RemainingTime(), 0, this.maximumRetries, PrepareAsyncCompletion(onSqlCommandAsyncResultCallback), this); sqlCommandResult.StartCommand(); if (!SyncContinue(sqlCommandResult)) { return; } } catch (InstancePersistenceException instancePersistenceException) { delayedException = instancePersistenceException; } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } delayedException = new InstancePersistenceCommandException(this.InstancePersistenceCommand.Name, instanceId, exception); } if (delayedException != null) { if (this.sqlCommand.Connection != null) { this.sqlCommand.Connection.Close(); } this.sqlCommand.Dispose(); this.TraceException(delayedException); } this.Complete(false, delayedException); }
private void StartOperation() { Guid instanceId = (this.InstancePersistenceContext != null) ? this.InstancePersistenceContext.InstanceView.InstanceId : Guid.Empty; Exception exception = null; try { this.sqlCommand = new SqlCommand(); this.GenerateSqlCommand(this.sqlCommand); this.sqlCommand.CommandText = this.GetSqlCommandText(); this.sqlCommand.CommandType = this.GetSqlCommandType(); StoreUtilities.TraceSqlCommand(this.sqlCommand, true); SqlCommandAsyncResult result = new SqlCommandAsyncResult(this.sqlCommand, this.ConnectionString, this.DependentTransaction, this.TimeoutHelper.RemainingTime(), 0, this.Store.MaxConnectionRetries, base.PrepareAsyncCompletion(onSqlCommandAsyncResultCallback), this); result.StartCommand(); if (!base.SyncContinue(result)) { return; } } catch (InstancePersistenceException exception2) { exception = exception2; } catch (Exception exception3) { if (Fx.IsFatal(exception3)) { throw; } exception = new InstancePersistenceCommandException(this.InstancePersistenceCommand.Name, instanceId, exception3); } if (exception != null) { if (this.sqlCommand.Connection != null) { this.sqlCommand.Connection.Close(); } this.sqlCommand.Dispose(); this.TraceException(exception); } base.Complete(false, exception); }
public static Exception GetError(XName commandName, CommandResult result, SqlDataReader reader) { Exception returnValue = null; if (result != CommandResult.Success) { switch (result) { case CommandResult.InstanceAlreadyExists: returnValue = new InstanceCollisionException(commandName, reader.GetGuid(1)); break; case CommandResult.InstanceLockNotAcquired: returnValue = new InstanceLockedException(commandName, reader.GetGuid(1), reader.GetGuid(2), ReadLockOwnerMetadata(reader)); break; case CommandResult.InstanceNotFound: returnValue = new InstanceNotReadyException(commandName, reader.GetGuid(1)); break; case CommandResult.KeyAlreadyExists: returnValue = new InstanceKeyCollisionException(commandName, Guid.Empty, new InstanceKey(reader.GetGuid(1)), Guid.Empty); break; case CommandResult.KeyNotFound: returnValue = new InstanceKeyNotReadyException(commandName, new InstanceKey(reader.GetGuid(1))); break; case CommandResult.InstanceLockLost: returnValue = new InstanceLockLostException(commandName, reader.GetGuid(1)); break; case CommandResult.InstanceCompleted: returnValue = new InstanceCompleteException(commandName, reader.GetGuid(1)); break; case CommandResult.KeyDisassociated: returnValue = new InstanceKeyCompleteException(commandName, new InstanceKey(reader.GetGuid(1))); break; case CommandResult.StaleInstanceVersion: returnValue = new InstanceLockLostException(commandName, reader.GetGuid(1)); break; case CommandResult.HostLockExpired: returnValue = new InstancePersistenceException(SR.HostLockExpired); break; case CommandResult.HostLockNotFound: returnValue = new InstancePersistenceException(SR.HostLockNotFound); break; case CommandResult.CleanupInProgress: returnValue = new InstancePersistenceCommandException(SR.CleanupInProgress); break; case CommandResult.InstanceAlreadyLockedToOwner: returnValue = new InstanceAlreadyLockedToOwnerException(commandName, reader.GetGuid(1), reader.GetInt64(2)); break; default: returnValue = new InstancePersistenceCommandException(SR.UnknownSprocResult(result)); break; } } return(returnValue); }
static bool SqlCommandAsyncResultCallback(IAsyncResult result) { SqlWorkflowInstanceStoreAsyncResult thisPtr = (SqlWorkflowInstanceStoreAsyncResult)result.AsyncState; Exception delayedException = null; bool completeFlag = true; try { using (thisPtr.sqlCommand) { using (SqlDataReader reader = SqlCommandAsyncResult.End(result)) { delayedException = thisPtr.ProcessSqlResult(reader); } } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } Guid instanceId = (thisPtr.InstancePersistenceContext != null) ? thisPtr.InstancePersistenceContext.InstanceView.InstanceId : Guid.Empty; delayedException = new InstancePersistenceCommandException(thisPtr.InstancePersistenceCommand.Name, instanceId, exception); } if (delayedException is InstanceAlreadyLockedToOwnerException) { InstanceAlreadyLockedToOwnerException alreadyLockedException = (InstanceAlreadyLockedToOwnerException)delayedException; long reclaimLockAtVersion = alreadyLockedException.InstanceVersion; if (!thisPtr.InstancePersistenceContext.InstanceView.IsBoundToInstance) { thisPtr.InstancePersistenceContext.BindInstance(alreadyLockedException.InstanceId); } IAsyncResult bindReclaimedAsyncResult = thisPtr.InstancePersistenceContext.BeginBindReclaimedLock(reclaimLockAtVersion, thisPtr.TimeoutHelper.RemainingTime(), thisPtr.PrepareAsyncCompletion(SqlWorkflowInstanceStoreAsyncResult.onBindReclaimed), thisPtr); if (!thisPtr.SyncContinue(bindReclaimedAsyncResult)) { completeFlag = false; } } else if (delayedException != null) { if (thisPtr.sqlCommand.Connection != null) { thisPtr.sqlCommand.Connection.Close(); } bool handled = false; thisPtr.OnSqlException(delayedException, out handled); if (!handled) { thisPtr.TraceException(delayedException); throw FxTrace.Exception.AsError(delayedException); } } if (completeFlag) { completeFlag = thisPtr.OnSqlProcessingComplete(); } return(completeFlag); }