protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { StructuredTracer.Correlate(); try { if (command is SaveWorkflowCommand) { return new TypedCompletedAsyncResult<bool>(SaveWorkflow(context, (SaveWorkflowCommand)command), callback, state); } else if (command is LoadWorkflowCommand) { return new TypedCompletedAsyncResult<bool>(LoadWorkflow(context, (LoadWorkflowCommand)command), callback, state); } else if (command is CreateWorkflowOwnerCommand) { return new TypedCompletedAsyncResult<bool>(CreateWorkflowOwner(context, (CreateWorkflowOwnerCommand)command), callback, state); } else if (command is DeleteWorkflowOwnerCommand) { return new TypedCompletedAsyncResult<bool>(DeleteWorkflowOwner(context, (DeleteWorkflowOwnerCommand)command), callback, state); } return new TypedCompletedAsyncResult<bool>(false, callback, state); } catch (Exception e) { return new TypedCompletedAsyncResult<Exception>(e, callback, state); } }
private IAsyncResult CreateWorkflowOwner(InstancePersistenceContext context, CreateWorkflowOwnerCommand command, TimeSpan timeout, AsyncCallback callback, object state) { var owner = new LockOwner() { Id = Guid.NewGuid(), }; // TODO: map fields into the owner entity Debug.WriteLine("CreateWorkflowOwner::InstanceOwnerMetadata: "); Debug.Indent(); foreach (var key in command.InstanceOwnerMetadata.Keys) { Debug.WriteLine("[{0}]=[{1}]", key, command.InstanceOwnerMetadata[key].Value); } Debug.Unindent(); //context.BindInstanceOwner(owner.Id, owner.Id); //context.BindEvent(HasRunnableWorkflowEvent.Value); //return new CompletedAsyncResult(callback, state); return null; }
public TryLoadRunnableWorkflowAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { if (base.Store.WorkflowHostType == Guid.Empty) { throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(command.Name, System.Activities.DurableInstancing.SR.TryLoadRequiresWorkflowType, null)); } }
//The persistence engine will send a variety of commands to the configured InstanceStore, //such as CreateWorkflowOwnerCommand, SaveWorkflowCommand, and LoadWorkflowCommand. //This method is where we will handle those commands protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { IDictionary<XName, InstanceValue> data; //The CreateWorkflowOwner command instructs the instance store to create a new instance owner bound to the instanace handle if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(this.ownerInstanceId, Guid.NewGuid()); } //The SaveWorkflow command instructs the instance store to modify the instance bound to the instance handle or an instance key else if (command is SaveWorkflowCommand) { var saveCommand = (SaveWorkflowCommand)command; data = saveCommand.InstanceData; this.Save(data); } //The LoadWorkflow command instructs the instance store to lock and load the instance bound to the identifier in the instance handle else if (command is LoadWorkflowCommand) { var fileName = IoHelper.GetFileName(this.ownerInstanceId); using (var inputStream = new FileStream(fileName, FileMode.Open)) { data = LoadInstanceDataFromFile(inputStream); //load the data into the persistence Context context.LoadedInstance(InstanceState.Initialized, data, null, null, null); } } return new CompletedAsyncResult<bool>(true, callback, state); }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if(context == null) throw new ArgumentNullException("context"); if(command == null) throw new ArgumentNullException("command"); // Log which commands we are receiving Debug.WriteLine("InstanceStore::BeginTryCommand::{0} received", command.GetType().Name); IAsyncResult result = null; // validate the store lock if (command is CreateWorkflowOwnerCommand) { result = CreateWorkflowOwner(context, (CreateWorkflowOwnerCommand) command, timeout, callback, state); } if (result == null) { // Log which commands we are not handling Debug.WriteLine("InstanceStore::BeginTryCommand::{0} was not implemented", command.GetType().Name); // The base.BeginTryCommand will return a false (unhandled) return value return base.BeginTryCommand(context, command, timeout, callback, state); } return result; }
public SaveWorkflowAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { if (((SaveWorkflowCommand) command).InstanceKeyMetadataChanges.Count > 0) { throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(System.Activities.DurableInstancing.SR.InstanceKeyMetadataChangesNotSupported)); } }
public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, System.Runtime.DurableInstancing.InstancePersistenceContext context, System.Runtime.DurableInstancing.InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.InstanceStore = store; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.commandTimeout = new TimeoutHelper(timeout); this.InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, this.commandTimeout.RemainingTime(), onTryCommandCallback, this); }
protected internal virtual IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (try_command_delegate == null) { try_command_delegate = new Func <InstancePersistenceContext, InstancePersistenceCommand, TimeSpan, bool> (TryCommand); } return(try_command_delegate.BeginInvoke(context, command, timeout, callback, state)); }
internal IAsyncResult BeginTryCommandInternal(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { SqlWorkflowInstanceStoreAsyncResult result = null; if (command is SaveWorkflowCommand) { result = new SaveWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is TryLoadRunnableWorkflowCommand) { result = new TryLoadRunnableWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is LoadWorkflowCommand) { result = new LoadWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is LoadWorkflowByInstanceKeyCommand) { result = new LoadWorkflowByKeyAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is ExtendLockCommand) { result = new ExtendLockAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is DetectRunnableInstancesCommand) { result = new DetectRunnableInstancesAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is DetectActivatableWorkflowsCommand) { result = new DetectActivatableWorkflowsAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is RecoverInstanceLocksCommand) { result = new RecoverInstanceLocksAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is UnlockInstanceCommand) { result = new UnlockInstanceAsyncResult(null, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is CreateWorkflowOwnerCommand) { result = new CreateWorkflowOwnerAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is DeleteWorkflowOwnerCommand) { result = new DeleteWorkflowOwnerAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is QueryActivatableWorkflowsCommand) { result = new QueryActivatableWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else { return base.BeginTryCommand(context, command, timeout, callback, state); } result.ScheduleCallback(); return result; }
protected override IAsyncResult BeginTryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { switch(command.GetType().Name) { case "CreateWorkflowOwnerCommand": Func<Exception> createFunc = () => ProcessCreateWorkflowOwner(context, command as CreateWorkflowOwnerCommand); return createFunc.BeginInvoke(ar => { Exception ex = createFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "LoadWorkflowCommand": Func<Exception> loadFunc = () => ProcessLoadWorkflow(context, command as LoadWorkflowCommand); return loadFunc.BeginInvoke(ar => { Exception ex = loadFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "LoadWorkflowByInstanceKeyCommand": Func<Exception> loadByKeyFunc = () => ProcessLoadWorkflowByInstanceKey(context, command as LoadWorkflowByInstanceKeyCommand); return loadByKeyFunc.BeginInvoke(ar => { Exception ex = loadByKeyFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "SaveWorkflowCommand": Func<Exception> saveFunc = () => ProcessSaveWorkflow(context, command as SaveWorkflowCommand); return saveFunc.BeginInvoke(ar => { Exception ex = saveFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); default: return base.BeginTryCommand( context, command, timeout, callback, state); } }
protected SqlWorkflowInstanceStoreAsyncResult(System.Runtime.DurableInstancing.InstancePersistenceContext context, System.Runtime.DurableInstancing.InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.DependentTransaction = (currentTransaction != null) ? currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete) : null; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.Store = store; this.StoreLock = storeLock; this.TimeoutHelper = new System.Runtime.TimeoutHelper(timeout); base.OnCompleting = (Action <AsyncResult, Exception>)Delegate.Combine(base.OnCompleting, finallyCallback); }
public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.InstanceStore = store; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.commandTimeout = new TimeoutHelper(timeout); InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, this.commandTimeout.RemainingTime(), LoadRetryAsyncResult.onTryCommandCallback, this); }
public ExtendLockAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, int.MaxValue, callback, state) { }
protected SqlWorkflowInstanceStoreAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : this(context, command, store, storeLock, currentTransaction, timeout, store.MaxConnectionRetries, callback, state) { }
public DetectActivatableWorkflowsAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { }
public TestDatabaseVersionAndRunAsyncResult( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, Version targetVersion, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { this.currentTransaction = currentTransaction; this.targetVersion = targetVersion; }
private bool SaveWorkflow(InstancePersistenceContext context, SaveWorkflowCommand command) { if (context.InstanceVersion == -1) { context.BindAcquiredLock(0); } if (command.CompleteInstance) { context.CompletedInstance(); } else { string instanceType = ""; const string InstanceTypeXName = "{urn:schemas-microsoft-com:System.Runtime.DurableInstancing/4.0/metadata}InstanceType"; InstanceValue instanceTypeInstanceValue; if (command.InstanceMetadataChanges.TryGetValue(InstanceTypeXName, out instanceTypeInstanceValue)) { instanceType = instanceTypeInstanceValue.Value.ToString(); } Dictionary<string, object> fullInstanceData = new Dictionary<string, object>(); fullInstanceData.Add("instanceId", context.InstanceView.InstanceId); fullInstanceData.Add("instanceOwnerId", context.InstanceView.InstanceOwner.InstanceOwnerId); fullInstanceData.Add("instanceData", SerializeablePropertyBag(command.InstanceData)); fullInstanceData.Add("instanceMetadata", SerializeInstanceMetadata(context, command)); foreach (KeyValuePair<XName, InstanceValue> property in command.InstanceMetadataChanges) { context.WroteInstanceMetadataValue(property.Key, property.Value); } context.PersistedInstance(command.InstanceData); _stores.Save(WorkflowStoreComponents.Definition | WorkflowStoreComponents.Metadata | WorkflowStoreComponents.Streams | WorkflowStoreComponents.TerminatingError | WorkflowStoreComponents.Timer | WorkflowStoreComponents.ActivityState | WorkflowStoreComponents.JobState, fullInstanceData); } return true; }
public IAsyncResult BeginExecute(InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (command == null) { throw Fx.Exception.ArgumentNull("command"); } if (handle == null) { throw Fx.Exception.ArgumentNull("handle"); } if (!object.ReferenceEquals(this, handle.Store)) { throw Fx.Exception.Argument("handle", SRCore.ContextNotFromThisStore); } TimeoutHelper.ThrowIfNegativeArgument(timeout); return(InstancePersistenceContext.BeginOuterExecute(handle, command, Transaction.Current, timeout, callback, state)); }
public LoadWorkflowAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { this.associatedInstanceKeys = new Dictionary<Guid, IDictionary<XName, InstanceValue>>(); this.completedInstanceKeys = new Dictionary<Guid, IDictionary<XName, InstanceValue>>(); this.objectSerializer = ObjectSerializerFactory.GetDefaultObjectSerializer(); }
internal InstancePersistenceContext AcquireExecutionContext(Transaction hostTransaction, TimeSpan timeout) { bool setOperationPending = false; InstancePersistenceContext result = null; try { result = AcquireContextAsyncResult.End(new AcquireContextAsyncResult(this, hostTransaction, timeout, out setOperationPending)); Fx.AssertAndThrow(result != null, "Null result returned from AcquireContextAsyncResult (synchronous)."); return(result); } finally { if (result == null && setOperationPending) { FinishOperation(); } } }
protected internal override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (context == null) { throw FxTrace.Exception.ArgumentNull("context"); } if (command == null) { throw FxTrace.Exception.ArgumentNull("command"); } if (!this.storeLock.IsValid && !(command is CreateWorkflowOwnerCommand)) { throw FxTrace.Exception.AsError(new InstanceOwnerException(command.Name, this.storeLock.LockOwnerId)); } if (this.IsRetryCommand(command)) { return new LoadRetryAsyncResult(this, context, command, timeout, callback, state); } return this.BeginTryCommandInternal(context, command, timeout, callback, state); }
bool DoAfterTransaction() { AcquireContextAsyncResult setWaitTo = null; try { lock (this.handle.ThisLock) { if (!this.handle.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if (HostTransaction == null) { this.executionContext = new InstancePersistenceContext(this.handle, this.timeoutHelper.RemainingTime()); } else { this.executionContext = new InstancePersistenceContext(this.handle, HostTransaction); } this.handle.AcquirePending = null; this.handle.CurrentExecutionContext = this.executionContext; this.handle.TooLateToEnlist = false; } if (HostTransaction != null) { WaitForHostTransaction = new AsyncWaitHandle(EventResetMode.ManualReset); HostTransaction.EnlistVolatile(this, EnlistmentOptions.None); setWaitTo = this; } } finally { this.handle.CurrentTransactionalAsyncResult = setWaitTo; } return(true); }
// ExtendLockAsyncResult and RecoverInstanceLocksAsyncResult directly call this ctor protected SqlWorkflowInstanceStoreAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, int maximumRetries, AsyncCallback callback, object state ) : base(callback, state) { this.DependentTransaction = (currentTransaction != null) ? currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete) : null; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.Store = store; this.StoreLock = storeLock; this.TimeoutHelper = new TimeoutHelper(timeout); this.OnCompleting += SqlWorkflowInstanceStoreAsyncResult.finallyCallback; this.maximumRetries = maximumRetries; }
AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending, bool synchronous, AsyncCallback callback, object state) : base(callback, state) { // Need to report back to the caller whether or not we set OperationPending. setOperationPending = false; this.handle = handle; HostTransaction = hostTransaction; this.timeoutHelper = new TimeoutHelper(timeout); AcquireContextAsyncResult transactionWait; bool reuseContext = false; lock (this.handle.ThisLock) { if (!this.handle.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if (this.handle.OperationPending) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.CommandExecutionCannotOverlap)); } setOperationPending = true; this.handle.OperationPending = true; transactionWait = this.handle.CurrentTransactionalAsyncResult; if (transactionWait != null) { Fx.Assert(this.handle.AcquirePending == null, "Overlapped acquires pending."); // If the transaction matches but is already completed (or completing), the easiest ting to do // is wait for it to complete, then try to re-enlist, and have that failure be the failure mode for Execute. // We do that by following the regular, non-matching transaction path. if (transactionWait.HostTransaction.Equals(hostTransaction) && !this.handle.TooLateToEnlist) { reuseContext = true; this.executionContext = transactionWait.ReuseContext(); this.handle.CurrentExecutionContext = this.executionContext; } else { this.handle.AcquirePending = this; } } } if (transactionWait != null) { Fx.Assert(transactionWait.IsCompleted, "Old AsyncResult must be completed by now."); // Reuse the existing InstanceExecutionContext if this is the same transaction we're waiting for. if (reuseContext) { Complete(true); return; } TimeSpan waitTimeout = this.timeoutHelper.RemainingTime(); if (synchronous) { if (!transactionWait.WaitForHostTransaction.Wait(waitTimeout)) { throw Fx.Exception.AsError(new TimeoutException(InternalSR.TimeoutOnOperation(waitTimeout))); } } else { if (!transactionWait.WaitForHostTransaction.WaitAsync(AcquireContextAsyncResult.onHostTransaction, this, waitTimeout)) { return; } } } if (DoAfterTransaction()) { Complete(true); } }
protected internal virtual bool TryCommand (InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException (); }
public void Free() { if (!this.providerObjectSet) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.HandleFreedBeforeInitialized)); } if (!IsValid) { return; } List <InstanceHandleReference> handlesPendingResolution = null; WaitForEventsAsyncResult resultToCancel = null; try { bool needNotification = false; InstancePersistenceContext currentContext = null; lock (ThisLock) { if (!IsValid) { return; } IsValid = false; IEnumerable <XName> eventsToUnbind = null; if (this.pendingOwnerEvents != null && this.pendingOwnerEvents.Count > 0) { eventsToUnbind = this.pendingOwnerEvents.Select(persistenceEvent => persistenceEvent.Name); } if (this.boundOwnerEvents != null && this.boundOwnerEvents.Count > 0) { eventsToUnbind = eventsToUnbind == null ? this.boundOwnerEvents : eventsToUnbind.Concat(this.boundOwnerEvents); } if (eventsToUnbind != null) { Fx.Assert(Owner != null, "How do we have owner events without an owner."); Store.RemoveHandleFromEvents(this, eventsToUnbind, Owner); } if (this.waitResult != null) { resultToCancel = this.waitResult; this.waitResult = null; } if (OperationPending) { if (AcquirePending != null) { // If in this stage, we need to short-circuit the pending transaction. Fx.Assert(CurrentTransactionalAsyncResult != null, "Should have a pending transaction if we are waiting for it."); CurrentTransactionalAsyncResult.WaitForHostTransaction.Set(); this.needFreedNotification = true; } else { // Here, just notify the currently executing command. Fx.Assert(CurrentExecutionContext != null, "Must have either this or AcquirePending set."); currentContext = CurrentExecutionContext; } } else { needNotification = true; if (this.inProgressBind != null) { Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if (Version != -1) { // This means the handle was successfully bound in the past. Need to remove it from the table of handles. Owner.Unbind(this); } } } if (currentContext != null) { // Need to do this not in a lock. currentContext.NotifyHandleFree(); lock (ThisLock) { if (OperationPending) { this.needFreedNotification = true; // Cancel any pending lock reclaim here. if (this.inProgressBind != null) { Fx.Assert(Owner != null, "Must be bound to owner to have an inProgressBind for the lock in CancelReclaim."); // Null reason defaults to OperationCanceledException. (Defer creating it since this might not be a // reclaim attempt, but we don't know until we take the HandlesLock.) Owner.FaultBind(ref this.inProgressBind, ref handlesPendingResolution, null); } } else { needNotification = true; } } } if (needNotification) { Store.FreeInstanceHandle(this, ProviderObject); } } finally { if (resultToCancel != null) { resultToCancel.Canceled(); } InstanceOwner.ResolveHandles(handlesPendingResolution); } }
protected internal virtual IAsyncResult BeginTryCommand (InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (try_command_delegate == null) try_command_delegate = new Func<InstancePersistenceContext, InstancePersistenceCommand, TimeSpan, bool> (TryCommand); return try_command_delegate.BeginInvoke (context, command, timeout, callback, state); }
public ExecuteAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) : this(command, timeout, null, null) { this.context = context; this.priorAsyncResult = this.context.LastAsyncResult; Fx.Assert(this.priorAsyncResult != null, "The LastAsyncResult should already have been checked."); this.priorAsyncResult.executeCalledByCurrentCommand = true; bool success = false; try { this.context.LastAsyncResult = this; RunLoopCore(true); success = true; } finally { this.context.LastAsyncResult = this.priorAsyncResult; if (!success && this.context.IsHandleDoomedByRollback) { this.context.InstanceHandle.Free(); } } Complete(true); }
public ExecuteAsyncResult(InstanceHandle initialInstanceHandle, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout) : this(command, timeout, null, null) { this.initialInstanceHandle = initialInstanceHandle; this.context = this.initialInstanceHandle.AcquireExecutionContext(transaction, this.timeoutHelper.RemainingTime()); Exception completionException = null; try { // After this stage, must complete explicitly in order to get Cleanup to run correctly. this.context.RootAsyncResult = this; this.context.LastAsyncResult = this; OnCompleting = new Action<AsyncResult, Exception>(Cleanup); RunLoopCore(true); if (this.transactionToCommit != null) { try { this.transactionToCommit.Commit(); } catch (TransactionException) { // Since we are enlisted in this transaction, we can ignore exceptions from Commit. } this.transactionToCommit = null; } DoWaitForTransaction(true); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } completionException = exception; } Complete(true, completionException); }
private bool DeleteWorkflowOwner(InstancePersistenceContext context, DeleteWorkflowOwnerCommand command) { return true; }
public void Free() { if (!this.providerObjectSet) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.HandleFreedBeforeInitialized)); } if (this.IsValid) { List <InstanceHandleReference> handlesPendingResolution = null; WaitForEventsAsyncResult waitResult = null; try { bool flag = false; InstancePersistenceContext currentExecutionContext = null; lock (this.ThisLock) { if (!this.IsValid) { return; } this.IsValid = false; IEnumerable <XName> first = null; if ((this.pendingOwnerEvents != null) && (this.pendingOwnerEvents.Count > 0)) { first = from persistenceEvent in this.pendingOwnerEvents select persistenceEvent.Name; } if ((this.boundOwnerEvents != null) && (this.boundOwnerEvents.Count > 0)) { first = (first == null) ? this.boundOwnerEvents : first.Concat <XName>(this.boundOwnerEvents); } if (first != null) { this.Store.RemoveHandleFromEvents(this, first, this.Owner); } if (this.waitResult != null) { waitResult = this.waitResult; this.waitResult = null; } if (this.OperationPending) { if (this.AcquirePending != null) { this.CurrentTransactionalAsyncResult.WaitForHostTransaction.Set(); this.needFreedNotification = true; } else { currentExecutionContext = this.CurrentExecutionContext; } } else { flag = true; if (this.inProgressBind != null) { this.Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if (this.Version != -1L) { this.Owner.Unbind(this); } } } if (currentExecutionContext != null) { currentExecutionContext.NotifyHandleFree(); lock (this.ThisLock) { if (this.OperationPending) { this.needFreedNotification = true; if (this.inProgressBind != null) { this.Owner.FaultBind(ref this.inProgressBind, ref handlesPendingResolution, null); } } else { flag = true; } } } if (flag) { this.Store.FreeInstanceHandle(this, this.ProviderObject); } } finally { if (waitResult != null) { waitResult.Canceled(); } InstanceOwner.ResolveHandles(handlesPendingResolution); } } }
private bool LoadWorkflow(InstancePersistenceContext context, LoadWorkflowCommand command) { if (command.AcceptUninitializedInstance) { return false; } if (context.InstanceVersion == -1) { context.BindAcquiredLock(0); } Guid instanceId = context.InstanceView.InstanceId; Guid instanceOwnerId = context.InstanceView.InstanceOwner.InstanceOwnerId; IDictionary<XName, InstanceValue> instanceData = null; IDictionary<XName, InstanceValue> instanceMetadata = null; Dictionary<string, object> fullInstanceData = _stores.LoadWorkflowContext(); instanceData = this.DeserializePropertyBag((Dictionary<XName, object>)fullInstanceData["instanceData"]); instanceMetadata = this.DeserializePropertyBag((Dictionary<XName, object>)fullInstanceData["instanceMetadata"]); context.LoadedInstance(InstanceState.Initialized, instanceData, instanceMetadata, null, null); return true; }
private bool CreateWorkflowOwner(InstancePersistenceContext context, CreateWorkflowOwnerCommand command) { Guid instanceOwnerId = Guid.NewGuid(); context.BindInstanceOwner(instanceOwnerId, instanceOwnerId); context.BindEvent(HasRunnableWorkflowEvent.Value); return true; }
public BindReclaimedLockAsyncResult(InstancePersistenceContext context, AsyncWaitHandle wait, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.context = context; if (wait.WaitAsync(BindReclaimedLockAsyncResult.waitComplete, this, timeout)) { this.context.ConcludeBindReclaimedLockHelper(); Complete(true); } }
public ExecuteAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : this(command, timeout, callback, state) { this.context = context; this.priorAsyncResult = this.context.LastAsyncResult; Fx.Assert(this.priorAsyncResult != null, "The LastAsyncResult should already have been checked."); this.priorAsyncResult.executeCalledByCurrentCommand = true; OnCompleting = new Action<AsyncResult, Exception>(SimpleCleanup); bool completeSelf = false; bool success = false; try { this.context.LastAsyncResult = this; if (RunLoop()) { completeSelf = true; } success = true; } finally { if (!success) { this.context.LastAsyncResult = this.priorAsyncResult; } } if (completeSelf) { Complete(true); } }
protected internal virtual bool TryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException(); }
private Dictionary<XName, object> SerializeInstanceMetadata(InstancePersistenceContext context, SaveWorkflowCommand command) { Dictionary<XName, object> metadata = null; foreach (var property in command.InstanceMetadataChanges) { if (!property.Value.Options.HasFlag(InstanceValueOptions.WriteOnly)) { if (metadata == null) { metadata = new Dictionary<XName, object>(); // copy current metadata. note that we must rid of InstanceValue as it is not properly serializeable foreach (var m in context.InstanceView.InstanceMetadata) { metadata.Add(m.Key, m.Value.Value); } } if (metadata.ContainsKey(property.Key)) { if (property.Value.IsDeletedValue) metadata.Remove(property.Key); else metadata[property.Key] = property.Value.Value; } else { if (!property.Value.IsDeletedValue) metadata.Add(property.Key, property.Value.Value); } } } if (metadata == null) metadata = new Dictionary<XName, object>(); return metadata; }
protected internal virtual bool TryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { return(EndTryCommand(BeginTryCommand(context, command, timeout, null, null))); }
private AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending, bool synchronous, AsyncCallback callback, object state) : base(callback, state) { InstanceHandle.AcquireContextAsyncResult currentTransactionalAsyncResult; setOperationPending = false; this.handle = handle; this.HostTransaction = hostTransaction; this.timeoutHelper = new TimeoutHelper(timeout); bool flag = false; lock (this.handle.ThisLock) { if (!this.handle.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if (this.handle.OperationPending) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.CommandExecutionCannotOverlap)); } setOperationPending = true; this.handle.OperationPending = true; currentTransactionalAsyncResult = this.handle.CurrentTransactionalAsyncResult; if (currentTransactionalAsyncResult != null) { if (currentTransactionalAsyncResult.HostTransaction.Equals(hostTransaction) && !this.handle.TooLateToEnlist) { flag = true; this.executionContext = currentTransactionalAsyncResult.ReuseContext(); this.handle.CurrentExecutionContext = this.executionContext; } else { this.handle.AcquirePending = this; } } } if (currentTransactionalAsyncResult != null) { if (flag) { base.Complete(true); return; } TimeSpan span = this.timeoutHelper.RemainingTime(); if (synchronous) { if (!currentTransactionalAsyncResult.WaitForHostTransaction.Wait(span)) { throw Fx.Exception.AsError(new TimeoutException(SRCore.TimeoutOnOperation(span))); } } else if (!currentTransactionalAsyncResult.WaitForHostTransaction.WaitAsync(onHostTransaction, this, span)) { return; } } if (this.DoAfterTransaction()) { base.Complete(true); } }
protected internal virtual IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { return(new CompletedAsyncResult <bool>(false, callback, state)); }
private bool DoAfterTransaction() { InstanceHandle.AcquireContextAsyncResult result = null; try { lock (this.handle.ThisLock) { if (!this.handle.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if (this.HostTransaction == null) { this.executionContext = new InstancePersistenceContext(this.handle, this.timeoutHelper.RemainingTime()); } else { this.executionContext = new InstancePersistenceContext(this.handle, this.HostTransaction); } this.handle.AcquirePending = null; this.handle.CurrentExecutionContext = this.executionContext; this.handle.TooLateToEnlist = false; } if (this.HostTransaction != null) { this.WaitForHostTransaction = new AsyncWaitHandle(EventResetMode.ManualReset); this.HostTransaction.EnlistVolatile(this, EnlistmentOptions.None); result = this; } } finally { this.handle.CurrentTransactionalAsyncResult = result; } return true; }
public InstanceView EndExecute(IAsyncResult result) { return(InstancePersistenceContext.EndOuterExecute(result)); }