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)); } }
protected override IAsyncResult BeginTryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { try { switch (command) { case SaveWorkflowCommand saveWorkflowCommand: return(new TypedCompletedAsyncResult <bool>(SaveWorkflow(context, saveWorkflowCommand), callback, state)); case LoadWorkflowCommand loadWorkflowCommand: return(new TypedCompletedAsyncResult <bool>(LoadWorkflow(context, loadWorkflowCommand), callback, state)); case CreateWorkflowOwnerCommand createWorkflowOwnerCommand: return(new TypedCompletedAsyncResult <bool>( CreateWorkflowOwner(context, createWorkflowOwnerCommand), callback, state)); case DeleteWorkflowOwnerCommand deleteWorkflowOwnerCommand: return(new TypedCompletedAsyncResult <bool>( DeleteWorkflowOwner(context, deleteWorkflowOwnerCommand), callback, state)); default: return(new TypedCompletedAsyncResult <bool>(false, callback, state)); } } catch (Exception e) { return(new TypedCompletedAsyncResult <Exception>(e, callback, state)); } }
/// <summary> /// The try command. /// </summary> /// <param name="context">The context.</param> /// <param name="command">The command.</param> /// <param name="timeout">The timeout.</param> /// <returns>The <see cref="bool" />.</returns> protected override bool TryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { return(this.EndTryCommand(this.BeginTryCommand(context, command, timeout, null, null))); }
public InstanceCommandWithTemporaryHandleAsyncResult(InstanceStore instanceStore, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.instanceStore = instanceStore; this.command = command; this.temporaryHandle = instanceStore.CreateInstanceHandle(); var currentTransaction = Transaction.Current; if (currentTransaction != null) { this.dependentTransaction = currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete); } this.OnCompleting = completeCallback; IAsyncResult result; using (this.PrepareTransactionalCall(this.dependentTransaction)) { result = instanceStore.BeginExecute(this.temporaryHandle, command, timeout, this.PrepareAsyncCompletion(commandCompletedCallback), this); } if (this.SyncContinue(result)) { this.Complete(true); } }
/// <summary> /// Handles a <see cref="InstancePersistenceCommand"/>. /// </summary> /// <param name="context"></param> /// <param name="command"></param> /// <returns></returns> Task <bool> CommandAsync(InstancePersistenceContext context, InstancePersistenceCommand command) { if (command is CreateWorkflowOwnerCommand) { return(CreateWorkflowOwnerCommand(context, (CreateWorkflowOwnerCommand)command)); } else if (command is QueryActivatableWorkflowsCommand) { return(QueryActivatableWorkflowsCommand(context, (QueryActivatableWorkflowsCommand)command)); } else if (command is SaveWorkflowCommand) { return(SaveWorkflowCommand(context, (SaveWorkflowCommand)command)); } else if (command is LoadWorkflowCommand) { return(LoadWorkflowCommand(context, (LoadWorkflowCommand)command)); } else if (command is TryLoadRunnableWorkflowCommand) { return(TryLoadRunnableWorkflowCommand(context, (TryLoadRunnableWorkflowCommand)command)); } else if (command is DeleteWorkflowOwnerCommand) { return(DeleteWorkflowOwnerCommand(context, (DeleteWorkflowOwnerCommand)command)); } else { return(Task.FromResult(true)); } }
private bool IsRetryCommand(InstancePersistenceCommand command) { if (!this.IsLockRetryEnabled()) { return(false); } return((command is LoadWorkflowByInstanceKeyCommand) || (command is LoadWorkflowCommand)); }
bool IsRetryCommand(InstancePersistenceCommand command) { return ( this.IsLockRetryEnabled() && ( command is LoadWorkflowByInstanceKeyCommand || command is LoadWorkflowCommand ) ); }
protected override bool TryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { ManualResetEvent waitEvent = new ManualResetEvent(false); IAsyncResult asyncResult = BeginTryCommand( context, command, timeout, ar => waitEvent.Set(), null); waitEvent.WaitOne(timeout); return(EndTryCommand(asyncResult)); }
public PersistenceTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, InstancePersistenceCommand instancePersistenceCommand, TimeSpan taskInterval, bool automaticallyResetTimer) { this.automaticallyResetTimer = automaticallyResetTimer; this.commandCompletedCallback = Fx.ThunkCallback(new AsyncCallback(this.CommandCompletedCallback)); this.instancePersistenceCommand = instancePersistenceCommand; this.Store = store; this.StoreLock = storeLock; this.SurrogateLockOwnerId = this.StoreLock.SurrogateLockOwnerId; this.taskInterval = taskInterval; this.thisLock = new object(); }
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); }
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)); } }
public LoadWorkflowByKeyAsyncResult ( 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) { }
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 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; }
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(); }
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, SR.TryLoadRequiresWorkflowType, null)); } }
private bool Load() { IAsyncResult result; if (this.ppd.store == null) { this.isInstanceInitialized = false; this.context = new PersistenceContext(this.ppd, (this.suggestedIdOrId == Guid.Empty) ? Guid.NewGuid() : this.suggestedIdOrId, this.key, this.associatedKeys); return(this.Finish()); } if (this.canCreateInstance && !this.lockInstance) { if (this.suggestedIdOrId == Guid.Empty) { this.suggestedIdOrId = Guid.NewGuid(); } this.handle = this.ppd.store.CreateInstanceHandle(this.ppd.owner, this.suggestedIdOrId); this.isInstanceInitialized = false; return(this.AfterLoad()); } InstancePersistenceCommand command = this.ppd.CreateLoadCommandHelper(this.key, out this.handle, this.canCreateInstance, this.suggestedIdOrId, this.associatedKeys, this.loadAny); try { using (base.PrepareTransactionalCall(this.transaction)) { result = this.ppd.store.BeginExecute(this.handle, command, this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(new AsyncResult.AsyncCompletion(PersistenceProviderDirectory.LoadOrCreateAsyncResult.HandleExecute)), this); } } catch (InstanceHandleConflictException) { result = null; } catch (InstanceLockLostException) { result = null; } if (result == null) { return(this.ResolveHandleConflict()); } return(base.SyncContinue(result)); }
/// <summary> /// The begin try command. /// </summary> /// <param name="context">The context.</param> /// <param name="command">The command.</param> /// <param name="timeout">The timeout.</param> /// <param name="callback">The callback.</param> /// <param name="state">The state.</param> /// <returns>The <see cref="IAsyncResult" />.</returns> /// <exception cref="SystemFailureException">Error processing message.</exception> protected override IAsyncResult BeginTryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { lock (LocalLock) { if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(this.ownerInstanceId, Guid.NewGuid()); } else { var saveWorkflowCommand = command as SaveWorkflowCommand; if (saveWorkflowCommand != null) { this.SaveInstanceData(saveWorkflowCommand.InstanceData); } else if (command is LoadWorkflowCommand) { try { var instanceData = this.unstructuredStorageRepository.GetById( "WorkflowInstanceStoreData", this.ownerInstanceId.ToString()); var deserializedData = DeserializeData(instanceData.Payload.Combine()); context.LoadedInstance(InstanceState.Initialized, deserializedData, null, null, null); } catch (Exception exception) { throw; } } } return(new CompletedAsyncResult <bool>(true, callback, state)); } }
// 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; }
// 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> instanceStateData = null; WorkflowInstance instance = null; Guid InstanceId = Guid.Empty; if (context != null && context.InstanceView != null) { InstanceId = context.InstanceView.InstanceId; instance = WorkflowInstance.Instances.Where(x => x.InstanceId == InstanceId.ToString()).FirstOrDefault(); } //The CreateWorkflowOwner command instructs the instance store to create a new instance owner bound to the instanace handle if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(_storeId, 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) { if (instance != null && instance.Workflow != null && instance.Workflow.Serializable == true) { SaveWorkflowCommand saveCommand = (SaveWorkflowCommand)command; try { instanceStateData = saveCommand.InstanceData; var instanceStateXml = DictionaryToXml(instanceStateData); Save(context.InstanceView.InstanceId, this._storeId, instanceStateXml); } catch (Exception) { instance.Workflow.Serializable = false; } } } //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 xml = Load(InstanceId, _storeId); // if (xml == null) throw new ArgumentNullException("Failed locating instance data for " + context.InstanceView.InstanceId.ToString()); // if (xml == null) return new CompletedAsyncResult<bool>(false, callback, state); if (xml == null) { return(new CompletedAsyncResult <bool>(true, callback, state)); } instanceStateData = XmlToDictionary(xml); //load the data into the persistence Context context.LoadedInstance(InstanceState.Initialized, instanceStateData, null, null, null); } return(new CompletedAsyncResult <bool>(true, callback, state)); }
//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 = null; //The CreateWorkflowOwner command instructs the instance store to create a new instance owner bound to the instanace handle if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(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) { SaveWorkflowCommand saveCommand = (SaveWorkflowCommand)command; data = saveCommand.InstanceData; 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) { string fileName = this.ownerInstanceID.ToString(); try { using (FileStream inputStream = new FileStream(fileName, FileMode.Open)) { data = LoadInstanceDataFromFile(inputStream); //load the data into the persistence Context context.LoadedInstance(InstanceState.Initialized, data, null, null, null); } } catch (Exception exception) { throw new Exception(exception.Message); } } return(new CompletedAsyncResult <bool>(true, callback, state)); }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { SaveWorkflowCommand save = command as SaveWorkflowCommand; if (save != null) { lock (FileStore.s_thisLock) { ProcessSaveCommand(context, save); } } LoadWorkflowCommand load = command as LoadWorkflowCommand; if (load != null) { lock (FileStore.s_thisLock) { ProcessLoadCommand(context, load); } } LoadWorkflowByInstanceKeyCommand loadByKey = command as LoadWorkflowByInstanceKeyCommand; if (loadByKey != null) { lock (FileStore.s_thisLock) { ProcessLoadByKeyCommand(context, loadByKey); } } if (save != null || load != null || loadByKey != null) { return(new CompletedAsyncResult(callback, state)); } if (command is CreateWorkflowOwnerCommand createOwner) { Guid ownerId = Guid.NewGuid(); Owner owner = new Owner(); lock (s_thisLock) { owner.Id = ownerId; owner.LockToken = Guid.NewGuid(); owner.Metadata = new PropertyBag(createOwner.InstanceOwnerMetadata); PersistenceItemManager.SaveToFile <Owner>(owner); } context.BindInstanceOwner(ownerId, owner.LockToken); context.BindEvent(HasRunnableWorkflowEvent.Value); return(new CompletedAsyncResult(callback, state)); } if (command is DeleteWorkflowOwnerCommand deleteOwner) { Guid ownerId = context.InstanceView.InstanceOwner.InstanceOwnerId; lock (FileStore.s_thisLock) { Owner owner = PersistenceItemManager.Load <Owner>(ownerId); if (owner != null && owner.LockToken == context.LockToken) { PersistenceItemManager.Remove <Owner>(ownerId); } } context.InstanceHandle.Free(); return(new CompletedAsyncResult(callback, state)); } return(base.BeginTryCommand(context, command, timeout, callback, state)); }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { try { return(base.BeginTryCommand(context, command, timeout, callback, state)); } catch (Exception e) { return(new TypedCompletedAsyncResult <Exception>(e, callback, state)); } }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(OwnerInstanceId, Guid.NewGuid()); } else if (command is SaveWorkflowCommand) { var saveCommand = (SaveWorkflowCommand)command; Save(context.InstanceView.InstanceId, saveCommand.InstanceData); } else if (command is LoadWorkflowCommand) { context.LoadedInstance(InstanceState.Initialized, Load(context.InstanceView.InstanceId), null, null, null); } else if (command is DeleteWorkflowOwnerCommand) { } return(new CompletedAsyncResult <bool>(true, 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 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)); }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { 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 CreateWorkflowOwnerWithIdentityCommand) { return(new TypedCompletedAsyncResult <bool>(CreateWorkflowOwnerWithIdentity(context, (CreateWorkflowOwnerWithIdentityCommand)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)); } }
// 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> instanceStateData = null; //The CreateWorkflowOwner command instructs the instance store to create a new instance owner bound to the instanace handle if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(_storeId, 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) { SaveWorkflowCommand saveCommand = (SaveWorkflowCommand)command; instanceStateData = saveCommand.InstanceData; var instanceStateXml = DictionaryToXml(instanceStateData); Save(context.InstanceView.InstanceId, this._storeId, instanceStateXml); } //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 xml = Load(context.InstanceView.InstanceId, this._storeId); instanceStateData = XmlToDictionary(xml); //load the data into the persistence Context context.LoadedInstance(InstanceState.Initialized, instanceStateData, null, null, null); } return(new CompletedAsyncResult <bool>(true, callback, state)); }
internal IAsyncResult BeginTryCommandInternal(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { return(BeginTryCommandInternal(context, command, Transaction.Current, timeout, callback, state)); }
internal IAsyncResult BeginTryCommandInternalWithVersionCheck(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state, Version targetVersion) { SqlWorkflowInstanceStoreAsyncResult sqlWorkflowInstanceStoreAsyncResult = new TestDatabaseVersionAndRunAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, targetVersion, callback, state); sqlWorkflowInstanceStoreAsyncResult.ScheduleCallback(); return(sqlWorkflowInstanceStoreAsyncResult); }