WorkflowServiceInstance.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.ServiceModel.Activities / System / ServiceModel / Activities / Dispatcher / WorkflowServiceInstance.cs / 1593321 / WorkflowServiceInstance.cs
                        

                        
                            //---------------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//---------------------------------------------------------------

namespace System.ServiceModel.Activities.Dispatcher 
{
    using System; 
    using System.Activities; 
    using System.Activities.Hosting;
    using System.Activities.Tracking; 
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis; 
    using System.Globalization;
    using System.Linq; 
    using System.Runtime; 
    using System.Runtime.DurableInstancing;
    using System.ServiceModel.Activation; 
    using System.ServiceModel.Activities;
    using System.ServiceModel.Activities.Description;
    using System.Threading;
    using System.Transactions; 
    using System.Xml.Linq;
 
    // WorkflowServiceInstance is free-threaded. It is responsible for the correct locking and usage of the underlying WorkflowInstance. 
    // Given that there are two simultaneous users of WorkflowInstance (WorkflowServiceInstance and Activities),
    // it is imperative that WorkflowServiceInstance only calls into WorkflowInstance when there are no activities executing 
    // (and thus no worries about colliding with AEC calls).

    // LOCKING SCHEME DESCRIPTION
    // AcquireLock* - These are the only locks that should call Enter on the WorkflowExecutionLock. 
    // ReleaseLock  - This is the only method that should call Exit on the WorkflowExecutionLock.
    // Lock Handoff - The lock is often handed off from one thread to another.  This is handled by 
    //   WorkflowExecutionLock itself.  If there is a waiter (someone called Enter) then the Exit call 
    //   will simply notify the first waiter.  The waiter is now responsible for the lock.
    //   NOTE: There is a small period of time where no one things they own the lock.  Exit has "handed 
    //   off the lock by calling Set on the waiter, but the waiter has not yet executed the code
    //   which sets ownsLock to true.
    // [....] Handoff - During [....] handoff the ref bool ownsLock will be set accordingly by the
    //   Acquire* method.  These methods should always be called in a try block with a finally 
    //   which calls ReleaseLock.
    // Async Handoff - During async handoff the callback can assume it has the lock if either 
    //   there was no exception (FastAsyncCallback) or the call to End sets the ref bool ownsLock 
    //   to true.  Note that in cases of async handoff there should always be a guarding ReleaseLock
    //   which releases the lock if the async call does not state that it has gone async. 
    // Scheduler Interactions - The scheduler's state MUST ONLY be changed with the activeOperationsLock
    //   held.  This is to guarantee that a Pause (Acquire) is not clobbered by a concurrently executing
    //   Resume (Release) resulting in an instance operation which times out when it shouldn't have.
    // ActiveOperations RefCount - The activeOperations ref count MUST be incremented before calling 
    //   any of the Enter variations and must be decremented after leaving the Enter.  ActiveOperations
    //   is how ReleaseLock determines whether to hand the lock off to a waiting operation or to continue 
    //   execution workflow when the workflow is in a runnable state. 
    // Future Innovation - If necessary we can consider iterating on the current code to provide
    //   better guarantees around async handoff.  For example, at the risk of starvation we could 
    //   actually exit the lock before notifying waiters rather than doing a direct handoff.
    [Fx.Tag.XamlVisible(false)]
    class WorkflowServiceInstance : WorkflowInstance
    { 
        static AsyncCallback handleEndReleaseInstance;
        static FastAsyncCallback lockAcquiredAsyncCallback = new FastAsyncCallback(OnLockAcquiredAsync); 
        static AsyncCallback trackCompleteDoneCallback; 
        static AsyncCallback trackIdleDoneCallback;
        static AsyncCallback trackUnhandledExceptionDoneCallback; 
        static ReadOnlyCollection emptyBookmarkInfoCollection = new ReadOnlyCollection(new List());

        WorkflowExecutionLock executorLock;
 
        PersistenceContext persistenceContext;
        PersistencePipeline persistencePipelineInUse; 
        bool abortingExtensions; 

        int activeOperations; 
        object activeOperationsLock;
        int handlerThreadId;
        bool isInHandler;
        List idleWaiters; 
        List nextIdleWaiters;
        List checkCanPersistWaiters; 
 
        // Used for synchronizing ResumeBookmark calls on the the load path from extensions (e.g DurableTimerExtension)
        AsyncWaitHandle workflowServiceInstanceReadyWaitHandle; 
        bool isWorkflowServiceInstanceReady;

        // Tracking for one-time actions per instance lifetime (these end up being persisted)
        bool hasRaisedCompleted; 
        bool hasPersistedDeleted;
 
        bool isRunnable; 
        BufferedReceiveManager bufferedReceiveManager;
        State state; 
        object thisLock;
        TransactionContext transactionContext;
        bool isInTransaction;
        bool isTransactedCancelled; 
        Dictionary> pendingOperations;
        int pendingOperationCount; 
        Guid instanceId; 

        // Used for synchronizing unload with persist 
        // This is to mark that the instance has made progress but has not been persisted by idle policy yet
        bool hasDataToPersist;

        // tracks the outstanding requests.  This contributes to idle calculations, and the list is notified 
        // if workflow completes in any way (including unhandled exception)
        List pendingRequests; 
 
        // Various Policies
        UnloadInstancePolicyHelper unloadInstancePolicy; 
        UnhandledExceptionPolicyHelper unhandledExceptionPolicy;
        int referenceCount;
        ThreadNeutralSemaphore acquireReferenceSemaphore;
 
        WorkflowServiceHost serviceHost;
        WorkflowCreationContext creationContext; 
        bool creationContextAborted; 
        IDictionary workflowOutputs;
        Exception terminationException; 
        ActivityInstanceState completionState;
        TimeSpan persistTimeout;
        TimeSpan trackTimeout;
        TimeSpan acquireLockTimeout; 

        //Tracking for increment of ASP.NET busy count 
        bool hasIncrementedBusyCount; 

        // dummy ctor only used to calculate IsLoadTransactionRequired 
        WorkflowServiceInstance(WorkflowServiceHost serviceHost)
            : base(serviceHost.Activity)
        {
        } 

        WorkflowServiceInstance(Activity workflowDefinition, Guid instanceId, WorkflowServiceHost serviceHost, PersistenceContext persistenceContext) 
            : base(workflowDefinition) 
        {
            this.serviceHost = serviceHost; 
            this.instanceId = instanceId;
            this.persistTimeout = serviceHost.PersistTimeout;
            this.trackTimeout = serviceHost.TrackTimeout;
            this.bufferedReceiveManager = serviceHost.Extensions.Find(); 

            if (persistenceContext != null) 
            { 
                this.persistenceContext = persistenceContext;
                this.persistenceContext.Closed += this.OnPersistenceContextClosed; 
            }

            this.thisLock = new object();
            this.pendingRequests = new List(); 
            this.executorLock = new WorkflowExecutionLock(this);
            this.activeOperationsLock = new object(); 
            this.acquireReferenceSemaphore = new ThreadNeutralSemaphore(1); 
            this.acquireLockTimeout = TimeSpan.MaxValue;
 
            // Two initial references are held:
            // The first referenceCount is owned by UnloadInstancePolicy (ReleaseInstance)
            this.referenceCount = 1;
            // The second referenceCount is owned by the loader / creator of the instance. 
            this.TryAddReference();
        } 
 
        static AsyncCallback TrackIdleDoneCallback
        { 
            get
            {
                if (trackIdleDoneCallback == null)
                { 
                    trackIdleDoneCallback = Fx.ThunkCallback(new AsyncCallback(OnTrackIdleDone));
                } 
 
                return trackIdleDoneCallback;
            } 
        }

        static AsyncCallback TrackUnhandledExceptionDoneCallback
        { 
            get
            { 
                if (trackUnhandledExceptionDoneCallback == null) 
                {
                    trackUnhandledExceptionDoneCallback = Fx.ThunkCallback(new AsyncCallback(OnTrackUnhandledExceptionDone)); 
                }

                return trackUnhandledExceptionDoneCallback;
            } 
        }
 
        static AsyncCallback TrackCompleteDoneCallback 
        {
            get 
            {
                if (trackCompleteDoneCallback == null)
                {
                    trackCompleteDoneCallback = Fx.ThunkCallback(new AsyncCallback(OnTrackCompleteDone)); 
                }
 
                return trackCompleteDoneCallback; 
            }
        } 

        // cache the results for perf from the extension container
        internal List PipelineModules
        { 
            get;
            private set; 
        } 

        public BufferedReceiveManager BufferedReceiveManager 
        {
            get
            {
                return this.bufferedReceiveManager; 
            }
        } 
 
        public override Guid Id
        { 
            get
            {
                return this.instanceId;
            } 
        }
 
        protected override bool SupportsInstanceKeys 
        {
            get 
            {
                return true;
            }
        } 

        bool IsIdle 
        { 
            get
            { 
                return this.Controller.State == WorkflowInstanceState.Idle;
            }
        }
 
        bool ShouldRaiseComplete
        { 
            get 
            {
                return this.Controller.State == WorkflowInstanceState.Complete && !this.hasRaisedCompleted; 
            }
        }

        bool ShouldRaiseIdle 
        {
            get 
            { 
                return this.IsIdle && !this.hasRaisedCompleted && this.state != State.Aborted;
            } 
        }

        bool IsHandlerThread
        { 
            get
            { 
                return this.isInHandler && this.handlerThreadId == Thread.CurrentThread.ManagedThreadId; 
            }
        } 

        UnloadInstancePolicyHelper UnloadInstancePolicy
        {
            get 
            {
                if (this.unloadInstancePolicy == null) 
                { 
                    this.unloadInstancePolicy = new UnloadInstancePolicyHelper(this, this.serviceHost.IdleTimeToPersist, this.serviceHost.IdleTimeToUnload);
                } 
                return this.unloadInstancePolicy;
            }
        }
 
        UnhandledExceptionPolicyHelper UnhandledExceptionPolicy
        { 
            get 
            {
                if (this.unhandledExceptionPolicy == null) 
                {
                    this.unhandledExceptionPolicy = new UnhandledExceptionPolicyHelper(this, this.serviceHost.UnhandledExceptionAction);
                }
                return this.unhandledExceptionPolicy; 
            }
        } 
 
        // create a dummy instance to configure extensions and determine if a load-time transaction is required
        public static bool IsLoadTransactionRequired(WorkflowServiceHost host) 
        {
            WorkflowServiceInstance instance = new WorkflowServiceInstance(host);
            instance.RegisterExtensionManager(host.WorkflowExtensions);
            return instance.GetExtensions().Any(module => module.IsLoadTransactionRequired); 
        }
 
        public static WorkflowServiceInstance InitializeInstance(PersistenceContext persistenceContext, Guid instanceId, Activity workflowDefinition, IDictionary loadedObject, WorkflowCreationContext creationContext, 
            SynchronizationContext synchronizationContext, WorkflowServiceHost serviceHost)
        { 
            Fx.Assert(workflowDefinition != null, "workflowDefinition cannot be null.");
            Fx.Assert(serviceHost != null, "serviceHost cannot be null!");
            Fx.Assert(instanceId != Guid.Empty, "instanceId cannot be empty.");
 
            WorkflowServiceInstance workflowInstance = new WorkflowServiceInstance(workflowDefinition, instanceId, serviceHost, persistenceContext)
            { 
                SynchronizationContext = synchronizationContext 
            };
 
            // let us initalize the instance level extensions here
            workflowInstance.SetupExtensions(serviceHost.WorkflowExtensions);

            if (loadedObject != null) 
            {
                InstanceValue stateValue; 
                object deserializedRuntimeState; 

                if (!loadedObject.TryGetValue(WorkflowNamespace.Workflow, out stateValue) || stateValue.Value == null) 
                {
                    throw FxTrace.Exception.AsError(
                        new InstancePersistenceException(SR.WorkflowInstanceNotFoundInStore(instanceId)));
                } 
                deserializedRuntimeState = stateValue.Value;
 
                if (loadedObject.TryGetValue(WorkflowServiceNamespace.CreationContext, out stateValue)) 
                {
                    workflowInstance.creationContext = (WorkflowCreationContext)stateValue.Value; 
                }

                if (persistenceContext.IsSuspended)
                { 
                    workflowInstance.state = State.Suspended;
                } 
                workflowInstance.Initialize(deserializedRuntimeState); 
            }
            else 
            {
                IList rootExecutionProperties = null;
                IDictionary workflowArguments = null;
                // Provide default CorrelationScope if root activity is not CorrelationScope 
                if (!(workflowDefinition is CorrelationScope))
                { 
                    rootExecutionProperties = new List(1) 
                    {
                        new CorrelationHandle() 
                    };
                }

                if (creationContext != null) 
                {
                    workflowArguments = creationContext.RawWorkflowArguments; 
                    workflowInstance.creationContext = creationContext; 
                }
                workflowInstance.Initialize(workflowArguments, rootExecutionProperties); 
            }

            return workflowInstance;
        } 

        void SetupExtensions(WorkflowInstanceExtensionManager extensionManager) 
        { 
            base.RegisterExtensionManager(extensionManager);
 
            // cache IPersistencePipelineModules
            IEnumerable modules = base.GetExtensions();
            int modulesCount = modules.Count();
            if (modulesCount > 0) 
            {
                this.PipelineModules = new List(modulesCount); 
                this.PipelineModules.AddRange(modules); 
            }
        } 

        void OnPersistenceContextClosed(object sender, EventArgs e)
        {
            if (this.persistenceContext.Aborted && !this.abortingExtensions) 
            {
                AbortInstance(new FaultException(OperationExecutionFault.CreateAbortedFault(SR.DefaultAbortReason)), false); 
            } 
        }
 
        // Call when GetInstance to perform operation
        bool TryAddReference()
        {
            bool success = false; 
            lock (this.thisLock)
            { 
                if (this.referenceCount > 0) 
                {
                    ++this.referenceCount; 
                    success = true;
                }
            }
            if (success) 
            {
                this.UnloadInstancePolicy.Cancel(); 
            } 
            return success;
        } 

        // Called by unload via unload policy
        bool TryReleaseLastReference()
        { 
            lock (this.thisLock)
            { 
                if (this.referenceCount == 1) 
                {
                    this.referenceCount = 0; 
                    return true;
                }
            }
            return false; 
        }
 
        // Called when terminating ongoing unload 
        void RecoverLastReference()
        { 
            lock (this.thisLock)
            {
                Fx.Assert(this.referenceCount == 0, "referenceCount must be 0 during unload");
                this.referenceCount = 1; 
            }
        } 
 
        // Release after operation done
        public int ReleaseReference() 
        {
            int refCount;
            lock (this.thisLock)
            { 
                Fx.AssertAndThrow(this.referenceCount > 1, "referenceCount must be greater than 1");
                refCount = --this.referenceCount; 
            } 
            StartUnloadInstancePolicyIfNecessary();
            return refCount; 
        }

        void StartUnloadInstancePolicyIfNecessary()
        { 
            // The conditions to start unload policy.
            // - referenceCount is 1.  Like COM, This is the last reference count hold by WorkflowServiceInstance itself. 
            //   It is incremented per command (control/resumebookmark) and decremented when command is done. 
            // - No lock pending.  In general, when referenceCount is 1, the executor lock is freed and WF is idled.
            //   There is, however, one narrow case for Persist activity.  When it goes async (executing Sql command), 
            //   the referenceCount is decremented to 1 but WF sheduler still busy.  In this case, we will let
            //   the lock release to initiate the policy.
            // - Not in transaction (TxCommit will take care of this).
            // - Must not be in completed or unloaded or aborted states. 
            // Note: it is okay to dirty read referenceCount and isLocked.  If the UnloadInstancePolicy starts before
            //   increment, the increment will correct and cancel it.  If the increment happens before, ReleaseReference 
            //   will have a chance to start the policy.  Same applies to isLocked. 
            if (this.referenceCount == 1 && !this.executorLock.IsLocked && !this.isInTransaction &&
                this.state != State.Completed && this.state != State.Unloaded && this.state != State.Aborted) 
            {
                this.UnloadInstancePolicy.Begin();
            }
        } 

        void AcquireLock(TimeSpan timeout, ref bool ownsLock) 
        { 
            Fx.Assert(!ownsLock, "We should never call acquire if we already think we own the lock.");
 
            if (this.IsHandlerThread)
            {
                // We're in a handler, on the handler thread, and doing work synchronously so we already have the lock
                return; 
            }
 
            if (!this.executorLock.TryEnter(ref ownsLock)) 
            {
                Fx.Assert(!ownsLock, "This should always match the return of TryEnter and is only useful in light of exceptions"); 

                bool incrementedActiveOperations = false;
                object lockToken = null;
 
                try
                { 
                    lock (this.activeOperationsLock) 
                    {
                        try 
                        {
                        }
                        finally
                        { 
                            this.activeOperations++;
                            incrementedActiveOperations = true; 
                        } 

                        // An exception occuring before we call PauseScheduler causes no issues/----s since 
                        // we'll just cleanup activeOperations and be in the same state as when AcquireLock
                        // was called.

                        this.Controller.RequestPause(); 

                        this.executorLock.SetupWaiter(ref lockToken); 
                    } 

                    // There is a ---- here which is solved by code in ReleaseLock.  In short, if we fail 
                    // to acquire the lock here but before we decrement activeOperations the workflow pauses
                    // then nothing will ever restart the workflow.  To that end, ReleaseLock does some
                    // special handling when it exits the lock and no one is waiting.
 
                    this.executorLock.Enter(timeout, ref lockToken, ref ownsLock);
                } 
                finally 
                {
                    if (incrementedActiveOperations) 
                    {
                        lock (this.activeOperationsLock)
                        {
                            this.activeOperations--; 
                        }
                    } 
 
                    this.executorLock.CleanupWaiter(lockToken, ref ownsLock);
                } 
            }
        }

        bool AcquireLockAsync(TimeSpan timeout, ref bool ownsLock, FastAsyncCallback callback, object state) 
        {
            return AcquireLockAsync(timeout, false, false, ref ownsLock, callback, state); 
        } 

        bool AcquireLockAsync(TimeSpan timeout, bool isAbortPriority, bool skipPause, ref bool ownsLock, FastAsyncCallback callback, object state) 
        {
            Fx.Assert(!ownsLock, "We should never call acquire if we already think we own the lock.");

            // We cannot just hand off the lock if we are in a handler thread 
            // because this might eventually go async (during the operation)
            // and we could have multiple operations occurring concurrently. 
 
            if (!this.executorLock.TryEnter(ref ownsLock))
            { 
                Fx.Assert(!ownsLock, "This should always match the return of TryEnter and is only useful in light of exceptions");

                bool incrementedActiveOperations = false;
                bool decrementActiveOperations = true; 
                object lockToken = null;
 
                try 
                {
                    lock (this.activeOperationsLock) 
                    {
                        try
                        {
                        } 
                        finally
                        { 
                            this.activeOperations++; 
                            incrementedActiveOperations = true;
                        } 

                        // An exception occuring before we call PauseScheduler causes no issues/----s since
                        // we'll just cleanup activeOperations and be in the same state as when AcquireLock
                        // was called. 

                        if (!skipPause) 
                        { 
                            this.Controller.RequestPause();
                        } 

                        this.executorLock.SetupWaiter(isAbortPriority, ref lockToken);
                    }
 
                    // If we get the lock here then we should decrement, otherwise
                    // it is up to the lock acquired callback 
                    decrementActiveOperations = this.executorLock.EnterAsync(timeout, ref lockToken, ref ownsLock, lockAcquiredAsyncCallback, new AcquireLockAsyncData(this, callback, state)); 
                    return decrementActiveOperations;
                } 
                finally
                {
                    if (incrementedActiveOperations && decrementActiveOperations)
                    { 
                        lock (this.activeOperationsLock)
                        { 
                            this.activeOperations--; 
                        }
                    } 

                    this.executorLock.CleanupWaiter(lockToken, ref ownsLock);
                }
            } 
            else
            { 
                return true; 
            }
        } 

        static void OnLockAcquiredAsync(object state, Exception asyncException)
        {
            AcquireLockAsyncData data = (AcquireLockAsyncData)state; 

            lock (data.Instance.activeOperationsLock) 
            { 
                data.Instance.activeOperations--;
            } 

            data.Callback(data.State, asyncException);
        }
 
        AsyncWaitHandle SetupIdleWaiter(ref bool ownsLock)
        { 
            AsyncWaitHandle idleEvent = new AsyncWaitHandle(EventResetMode.ManualReset); 

            lock (this.activeOperationsLock) 
            {
                if (this.idleWaiters == null)
                {
                    this.idleWaiters = new List(); 
                }
 
                this.idleWaiters.Add(idleEvent); 
            }
 
            ReleaseLock(ref ownsLock);

            return idleEvent;
        } 

        bool CleanupIdleWaiter(AsyncWaitHandle idleEvent, Exception waitException, ref bool ownsLock) 
        { 
            lock (this.activeOperationsLock)
            { 
                if (!this.idleWaiters.Remove(idleEvent))
                {
                    // If it wasn't in the list that means we ----d between throwing from Wait
                    // and setting the event.  This thread now is responsible for the lock. 
                    if (waitException is TimeoutException)
                    { 
                        // In the case of Timeout we let setting the event win and signal to 
                        // ---- the exception
 
                        ownsLock = true;
                        return false;
                    }
                } 
            }
 
            return true; 
        }
 
        // Called with the executor lock
        // Returns true if someone was notified (this thread no longer owns the lock) or false if
        // no one was notified.
        bool NotifyNextIdleWaiter(ref bool ownsLock) 
        {
            // If we are no longer active, flush all idle waiters (next + current) because we will 
            // not enter Idle state again.  For Suspended, even we could ---- to unsuspend and become idle, 
            // the desirable behavior while suspending is to reject pending as well as new requests.
            if (this.state != State.Active) 
            {
                PrepareNextIdleWaiter();
            }
 
            if (this.idleWaiters != null && this.idleWaiters.Count > 0)
            { 
                // We need to be careful about setting this event because if there is an async 
                // waiter then this thread will be used for some execution.  Therefore we shouldn't
                // call set with the activeOperationsLock held. 
                AsyncWaitHandle idleEvent = null;

                // We need to lock this because a waiter might have timed out (or thrown another exception) and
                // could be trying to remove itself from the list without the executor lock. 
                lock (this.activeOperationsLock)
                { 
                    if (this.idleWaiters.Count > 0) 
                    {
                        idleEvent = this.idleWaiters[0]; 
                        this.idleWaiters.RemoveAt(0);
                    }
                }
 
                if (idleEvent != null)
                { 
                    idleEvent.Set(); 
                    ownsLock = false;
                    return true; 
                }
            }

            return false; 
        }
 
        void PrepareNextIdleWaiter() 
        {
            if (this.nextIdleWaiters != null && this.nextIdleWaiters.Count > 0) 
            {
                lock (this.activeOperationsLock)
                {
                    if (this.idleWaiters == null) 
                    {
                        this.idleWaiters = new List(); 
                    } 

                    for (int i = 0; i < this.nextIdleWaiters.Count; i++) 
                    {
                        this.idleWaiters.Add(this.nextIdleWaiters[i]);
                    }
                } 

                this.nextIdleWaiters.Clear(); 
            } 
        }
 
        IAsyncResult BeginAcquireLockOnIdle(TimeSpan timeout, ref bool ownsLock, AsyncCallback callback, object state)
        {
            return new AcquireLockOnIdleAsyncResult(this, timeout, ref ownsLock, callback, state);
        } 

        void EndAcquireLockOnIdle(IAsyncResult result) 
        { 
            Fx.Assert(result.CompletedSynchronously, "This overload should only be called when completed synchronously.");
            AcquireLockOnIdleAsyncResult.End(result); 
        }

        void EndAcquireLockOnIdle(IAsyncResult result, ref bool ownsLock)
        { 
            Fx.Assert(!result.CompletedSynchronously, "This overload should only be called when completed asynchronously.");
            AcquireLockOnIdleAsyncResult.End(result, ref ownsLock); 
        } 

        void ReleaseLock(ref bool ownsLock) 
        {
            ReleaseLock(ref ownsLock, false);
        }
 
        void ReleaseLock(ref bool ownsLock, bool hasBeenPersistedByIdlePolicy)
        { 
            // The hasBeenPersistedByIdlePolicy flag is only true when this is part of the idle policy initiated persist. 

            if (!ownsLock) 
            {
                return;
            }
 
            Fx.Assert(!this.IsHandlerThread, "We never set ownsLock if we are on the handler thread and therefore should have shortcut out earlier.");
 
            bool resumeScheduler = false; 

            bool needToSignalWorkflowServiceInstanceReadyWaitHandle = false; 
            lock (this.thisLock)
            {
                this.isWorkflowServiceInstanceReady = true;
                if (this.workflowServiceInstanceReadyWaitHandle != null) 
                {
                    needToSignalWorkflowServiceInstanceReadyWaitHandle = true; 
                } 

                // Signal that workflow has made progress and this progress has not been persisted by idle policy, 
                // we need to supress the abort initiated by unload when TimeToPersist < TimeToUnload.
                // If ReleaseLock is done by anyone other than idle policy persist, we mark the instance dirty.
                // Conversely, if idle policy completed a persist, we mark the instance clean.
                this.hasDataToPersist = !hasBeenPersistedByIdlePolicy; 
            }
 
            if (needToSignalWorkflowServiceInstanceReadyWaitHandle) 
            {
                this.workflowServiceInstanceReadyWaitHandle.Set(); 
            }

            lock (this.activeOperationsLock)
            { 
                // We don't check for completion here because we need to make sure we always
                // drain the scheduler queue.  Note that the OnIdle handler only raises events 
                // if the workflow is truly idle.  Therefore, if we are completed but not idle 
                // then we won't raise the events.
                // Terminate capitalizes on this by assuring that there is at least one more 
                // work item in the queue.  This provides a simple mechanism for getting a
                // scheduler thread to raise the completed event.
                bool isRunnable = this.state == State.Active && this.isRunnable && !this.IsIdle;
                if (isRunnable && this.activeOperations == 0) 
                {
                    ownsLock = false; 
                    resumeScheduler = true; 
                }
                else if ((this.IsIdle || this.state != State.Active) && NotifyNextIdleWaiter(ref ownsLock)) 
                {
                }
                else
                { 
                    // If we are runnable then we want to hang onto the lock if Exit finds no one waiting.
                    if (!this.executorLock.Exit(isRunnable, ref ownsLock)) 
                    { 
                        // No one was waiting, but we had activeOperations (otherwise we would not have gotten
                        // to this branch of the if).  This means that we ----d with a timeout and should resume 
                        // the workflow's execution.  If we don't resume execution we'll just hang ... no one
                        // has the lock, the workflow is ready to execute, but it is not.
                        Fx.Assert(this.activeOperations > 0, "We should always have active operations otherwise we should have taken a different code path.");
 
                        // We no longer "own" the lock because the scheduler has taken control
                        ownsLock = false; 
 
                        resumeScheduler = true;
                    } 
                }
            }

            if (resumeScheduler) 
            {
                IncrementBusyCount(); 
                this.persistenceContext.Bookmarks = null; 
                if (this.Controller.State == WorkflowInstanceState.Complete)
                { 
                    OnNotifyPaused();
                }
                else
                { 
                    this.Controller.Run();
                } 
            } 
        }
 
        public IAsyncResult BeginAbandon(Exception reason, TimeSpan timeout, AsyncCallback callback, object state)
        {
            Fx.Assert(reason != null, "reason must not be null!");
            return BeginAbandon(reason, true, timeout, callback, state); 
        }
 
        //used by UnloadPolicy when TimeToUnload > TimeToPersist to prevent an Abort tracking record. 
        IAsyncResult BeginAbandon(Exception reason, bool shouldTrackAbort, TimeSpan timeout, AsyncCallback callback, object state)
        { 
            return AbandonAsyncResult.Create(this, reason, shouldTrackAbort, timeout, callback, state);
        }

        public void EndAbandon(IAsyncResult result) 
        {
            AbandonAsyncResult.End(result); 
        } 

        IAsyncResult BeginAbandonAndSuspend(Exception reason, TimeSpan timeout, AsyncCallback callback, object state) 
        {
            Fx.Assert(reason != null, "reason must not be null!");
            return AbandonAndSuspendAsyncResult.Create(this, reason, timeout, callback, state);
        } 

        void EndAbandonAndSuspend(IAsyncResult result) 
        { 
            AbandonAndSuspendAsyncResult.End(result);
        } 

        void AbortInstance(Exception reason, bool isWorkflowThread)
        {
            AbortInstance(reason, isWorkflowThread, true); 
        }
 
        void AbortInstance(Exception reason, bool isWorkflowThread, bool shouldTrackAbort) 
        {
            bool completeSelf = false; 

            if (shouldTrackAbort)
            {
                FxTrace.Exception.AsWarning(reason); 
            }
 
            FaultPendingRequests(reason); 

            AbortExtensions(); 

            try
            {
                if (this.creationContext != null && !this.creationContextAborted) 
                {
                    this.creationContextAborted = true; 
                    this.creationContext.OnAbort(); 
                }
 
                if (isWorkflowThread)
                {
                    completeSelf = true;
                    if (ValidateStateForAbort()) 
                    {
                        this.state = State.Aborted; 
                        if (shouldTrackAbort) 
                        {
                            this.Controller.Abort(reason); 
                        }
                        else
                        {
                            // this ensures that reason is null when WorkflowInstance.Abort is called 
                            // and prevents an Abort tracking record.
                            this.Controller.Abort(); 
                        } 
                        DecrementBusyCount();
 
                        // We should get off this thread because we're unsure of its state
                        ScheduleTrackAndRaiseAborted(reason);
                    }
                } 
                else
                { 
                    bool ownsLock = false; 

                    try 
                    {
                        if (AcquireLockAsync(this.acquireLockTimeout, true, false, ref ownsLock, new FastAsyncCallback(OnAbortLockAcquired),
                            new AbortInstanceState(reason, shouldTrackAbort)))
                        { 
                            completeSelf = true;
                            if (ValidateStateForAbort()) 
                            { 
                                this.state = State.Aborted;
                                if (shouldTrackAbort) 
                                {
                                    this.Controller.Abort(reason);
                                }
                                else 
                                {
                                    // this ensures that reason is null when WorkflowInstance.Abort is called 
                                    // and prevents an Abort tracking record. 
                                    this.Controller.Abort();
                                } 
                                DecrementBusyCount();

                                // We need to get off this thread so we don't block the caller
                                // of abort 
                                ScheduleTrackAndRaiseAborted(reason);
                            } 
                        } 
                    }
                    finally 
                    {
                        if (completeSelf)
                        {
                            ReleaseLock(ref ownsLock); 
                        }
                    } 
                } 
            }
            finally 
            {
                this.serviceHost.FaultServiceHostIfNecessary(reason);
            }
        } 

        void AbortExtensions() 
        { 
            this.abortingExtensions = true;
 
            // Need to ensure that either components see the Aborted state, this method sees the components, or both.
            Thread.MemoryBarrier();

            if (this.persistenceContext != null) 
            {
                this.persistenceContext.Abort(); 
            } 

            PersistencePipeline currentPersistencePipeline = this.persistencePipelineInUse; 
            if (currentPersistencePipeline != null)
            {
                currentPersistencePipeline.Abort();
            } 

            // We abandon buffered Receives only in the complete code path, not in abort code path. 
            if (this.hasRaisedCompleted && this.bufferedReceiveManager != null) 
            {
                this.bufferedReceiveManager.AbandonBufferedReceives(this.persistenceContext.AssociatedKeys); 
            }

        }
 
        void Dispose()
        { 
            this.DisposeExtensions(); 

            // We abandon buffered Receives only in the complete code path, not in abort code path. 
            if (this.hasRaisedCompleted && this.bufferedReceiveManager != null)
            {
                this.bufferedReceiveManager.AbandonBufferedReceives(this.persistenceContext.AssociatedKeys);
            } 
        }
 
        void OnAbortLockAcquired(object state, Exception exception) 
        {
            if (exception != null) 
            {
                // We ---- this exception because we were simply doing our
                // best to get the lock.  Note that we won't proceed without
                // the lock because we may have already succeeded on another 
                // thread.  Technically this abort call has failed.
 
                FxTrace.Exception.AsWarning(exception); 
                return;
            } 

            bool ownsLock = true;
            bool shouldRaise = false;
            AbortInstanceState abortInstanceState = (AbortInstanceState)state; 

            try 
            { 
                if (ValidateStateForAbort())
                { 
                    shouldRaise = true;
                    this.state = State.Aborted;
                    if (abortInstanceState.ShouldTrackAbort)
                    { 
                        this.Controller.Abort(abortInstanceState.Reason);
                    } 
                    else 
                    {
                        // this ensures that reason is null when WorkflowInstance.Abort is called 
                        // and prevents an Abort tracking record.
                        this.Controller.Abort();
                    }
                    DecrementBusyCount(); 
                }
            } 
            finally 
            {
                ReleaseLock(ref ownsLock); 
            }

            if (shouldRaise)
            { 
                // We call this from this thread because we've already
                // had a thread switch 
                TrackAndRaiseAborted(abortInstanceState.Reason); 
            }
        } 

        void ScheduleTrackAndRaiseAborted(Exception reason)
        {
            ActionItem.Schedule(new Action