Ejemplo n.º 1
0
		internal WorkflowInstance (Guid guid, WorkflowRuntime runtime, Activity root_activity)
		{
			this.guid = guid;
			this.runtime = runtime;
			this.root_activity = root_activity;
			subscription_collection = new TimerEventSubscriptionCollection ();
			queuing_service = new WorkflowQueuingService ();
		}
 // inner Q service constructor
 internal WorkflowQueuingService(WorkflowQueuingService copyFromQueuingService)
 {
     this.rootQueuingService = copyFromQueuingService;
     this.rootWorkflowExecutor = copyFromQueuingService.rootWorkflowExecutor;
     this.rootWorkflowExecutor.RootActivity.SetValue(WorkflowQueuingService.PendingMessagesProperty, this.pendingQueueState.Messages);
     this.persistedQueueStates = new Dictionary<IComparable, EventQueueState>();
     this.rootWorkflowExecutor.RootActivity.SetValue(WorkflowQueuingService.LocalPersistedQueueStatesProperty, this.persistedQueueStates);
     SubscribeForRootMessageDelivery();
 }
 private void AddMessageArrivedEventHandler(WorkflowQueuingService handler)
 {
     lock (this.SyncRoot)
     {
         if (this.messageArrivalEventHandlers == null)
         {
             this.messageArrivalEventHandlers = new List<WorkflowQueuingService>();
         }
         this.messageArrivalEventHandlers.Add(handler);
     }
 }
        internal static object DequeueMessage(IComparable queueId, WorkflowQueuingService queueSvcs, Activity activity, out WorkflowQueue queue)
        {
            object message = null;
            queue = queueSvcs.GetWorkflowQueue(queueId);

            if (queue.Count != 0)
            {
                message = queue.Dequeue();
                if (message == null)
                    throw new ArgumentException(SR.GetString(SR.Error_InvalidEventMessage, activity.QualifiedName));
            }
            return message;
        }
 internal static object DequeueMessage(IComparable queueId, WorkflowQueuingService queueSvcs, Activity activity, out WorkflowQueue queue)
 {
     object obj2 = null;
     queue = queueSvcs.GetWorkflowQueue(queueId);
     if (queue.Count != 0)
     {
         obj2 = queue.Dequeue();
         if (obj2 == null)
         {
             throw new ArgumentException(SR.GetString("Error_InvalidEventMessage", new object[] { activity.QualifiedName }));
         }
     }
     return obj2;
 }
        protected override void OnActivityExecutionContextLoad(IServiceProvider provider)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.AsyncUpdateResourceOnActivityExecutionContextLoad);

            try
            {
                Logger.SetContextItem(this, this.WorkflowInstanceId);

                base.OnActivityExecutionContextLoad(provider);

                // Load the data access service via reflection
                Assembly assembly = Assembly.GetAssembly(typeof(UpdateResourceActivity));

                const string TypeName = "Microsoft.ResourceManagement.Workflow.Runtime.DataAccessService";
                this.dataAccessServiceType = assembly.GetType(TypeName);
                if (this.dataAccessServiceType == null)
                {
                    throw Logger.Instance.ReportError(new WorkflowActivityLibraryException(Messages.DefinitionsConverter_NullOrEmptyDefinitionsTableError, TypeName));
                }

                this.dataAccessService = provider.GetService(this.dataAccessServiceType);
                this.queuingService = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService));
            }
            finally
            {
                Logger.Instance.WriteMethodExit(EventIdentifier.AsyncUpdateResourceOnActivityExecutionContextLoad);
            } 
        }
Ejemplo n.º 7
0
		internal WorkflowQueue (WorkflowQueuingService service, IComparable queue_name)
		{
			queue = new Queue <object> ();
			this.service = service;
			this.queue_name = queue_name;
		}
Ejemplo n.º 8
0
        // Used to recreate the root schedule executor from its persisted state
        private void ReloadHelper(Activity rootActivity)
        {
            // assign activity state
            this.rootActivity = rootActivity;
            this.InstanceId = (Guid)rootActivity.GetValue(WorkflowInstanceIdProperty);

            // set workflow executor
            this.rootActivity.SetValue(WorkflowExecutor.WorkflowExecutorProperty, this);

            this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);

            this.schedulingContext = new Scheduler(this, false);
            this.qService = new WorkflowQueuingService(this);

            WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: Loading instance {0}", this.InstanceIdString);
            DiagnosticStackTrace("load request");

            using (new ServiceEnvironment(this.rootActivity))
            {

                // check if this instance can be loaded
                switch (this.WorkflowStatus)
                {
                    case WorkflowStatus.Completed:
                    case WorkflowStatus.Terminated:
                        WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 0, "Workflow Runtime: WorkflowExecutor: attempt to load a completed/terminated instance: {0}", this.InstanceIdString);
                        throw new InvalidOperationException(
                            ExecutionStringManager.InvalidAttemptToLoad);

                    default:
                        break;
                }

                // new nonSerialized members
                _resourceManager = new VolatileResourceManager();
                _runtime = _workflowInstance.WorkflowRuntime;

                // register all dynamic activities for loading
                Queue<Activity> dynamicActivitiesQueue = new Queue<Activity>();
                dynamicActivitiesQueue.Enqueue(this.rootActivity);
                while (dynamicActivitiesQueue.Count > 0)
                {
                    Activity dynamicActivity = dynamicActivitiesQueue.Dequeue();
                    ((IDependencyObjectAccessor)dynamicActivity).InitializeInstanceForRuntime(this);
                    this.RegisterDynamicActivity(dynamicActivity, true);

                    IList<Activity> nestedDynamicActivities = (IList<Activity>)dynamicActivity.GetValue(Activity.ActiveExecutionContextsProperty);
                    if (nestedDynamicActivities != null)
                    {
                        foreach (Activity nestedDynamicActivity in nestedDynamicActivities)
                            dynamicActivitiesQueue.Enqueue(nestedDynamicActivity);
                    }
                }
            }

            this.isInstanceIdle = (bool)this.rootActivity.GetValue(IsIdleProperty);
            RefreshWorkflowDefinition();
        }
Ejemplo n.º 9
0
        // Initialize for the root schedule
        internal void Initialize(Activity rootActivity, WorkflowExecutor invokerExec, string invokeActivityID, Guid instanceId, IDictionary<string, object> namedArguments, WorkflowInstance workflowInstance)
        {
            this.rootActivity = rootActivity;
            this.InstanceId = instanceId;

            // Set the persisted State properties
            this.rootActivity.SetValue(WorkflowExecutor.ContextIdProperty, 0);
            this.rootActivity.SetValue(WorkflowInstanceIdProperty, instanceId);
            this.WorkflowStatus = WorkflowStatus.Created;
            this.rootActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, new ActivityExecutionContextInfo(this.rootActivity.QualifiedName, GetNewContextId(), instanceId, -1));
            this.rootActivity.SetValue(Activity.ActivityContextGuidProperty, instanceId);
            this.rootActivity.SetValue(WorkflowExecutor.IsIdleProperty, true);
            this.isInstanceIdle = true;

            // set workflow executor
            this.rootActivity.SetValue(WorkflowExecutor.WorkflowExecutorProperty, this);

            // initialize the root activity
            RefreshWorkflowDefinition();
            Activity workflowDefinition = this.WorkflowDefinition;
            if (workflowDefinition == null)
                throw new InvalidOperationException("workflowDefinition");

            ((IDependencyObjectAccessor)this.rootActivity).InitializeActivatingInstanceForRuntime(null, this);
            this.rootActivity.FixUpMetaProperties(workflowDefinition);
            _runtime = workflowInstance.WorkflowRuntime;

            if (invokerExec != null)
            {
                List<string> calleeBase = new List<string>();
                TrackingCallingState parentTCS = (TrackingCallingState)invokerExec.rootActivity.GetValue(WorkflowExecutor.TrackingCallingStateProperty);
                if ((parentTCS != null) && (parentTCS.CallerActivityPathProxy != null))
                {
                    foreach (string qualifiedID in parentTCS.CallerActivityPathProxy)
                        calleeBase.Add(qualifiedID);
                }
                calleeBase.Add(invokeActivityID);

                //
                // This has been exec'd by another instance
                // Set up tracking info to allow linking instances
                Debug.Assert(invokeActivityID != null && invokeActivityID.Length > 0);
                TrackingCallingState trackingCallingState = new TrackingCallingState();
                trackingCallingState.CallerActivityPathProxy = calleeBase;
                trackingCallingState.CallerWorkflowInstanceId = invokerExec.InstanceId;
                trackingCallingState.CallerContextGuid = ((ActivityExecutionContextInfo)ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
                if (null == invokerExec.CurrentActivity.Parent)
                    trackingCallingState.CallerParentContextGuid = trackingCallingState.CallerContextGuid;
                else
                    trackingCallingState.CallerParentContextGuid = ((ActivityExecutionContextInfo)ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity.Parent).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
                this.rootActivity.SetValue(WorkflowExecutor.TrackingCallingStateProperty, trackingCallingState);
            }

            _setInArgsOnCompanion(namedArguments);

            this.schedulingContext = new Scheduler(this, true);
            this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);

            qService = new WorkflowQueuingService(this);

            _workflowInstance = workflowInstance;

            TimerQueue = new TimerEventSubscriptionCollection(this, this.InstanceId);

            // register the dynamic activity
            using (new ServiceEnvironment(this.rootActivity))
            {
                using (SetCurrentActivity(this.rootActivity))
                {
                    this.RegisterDynamicActivity(this.rootActivity, false);
                }
            }
        }
Ejemplo n.º 10
0
 internal WorkflowQueue(WorkflowQueuingService qService, IComparable queueName)
 {
     this.qService = qService;
     this.queueName = queueName;
 }
 private void ReloadHelper(Activity rootActivity)
 {
     this.rootActivity = rootActivity;
     this.InstanceId = (Guid) rootActivity.GetValue(WorkflowInstanceIdProperty);
     this.rootActivity.SetValue(WorkflowExecutorProperty, this);
     this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
     this.schedulingContext = new System.Workflow.Runtime.Scheduler(this, false);
     this.qService = new WorkflowQueuingService(this);
     WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: Loading instance {0}", new object[] { this.InstanceIdString });
     using (new ServiceEnvironment(this.rootActivity))
     {
         switch (this.WorkflowStatus)
         {
             case System.Workflow.Runtime.WorkflowStatus.Completed:
             case System.Workflow.Runtime.WorkflowStatus.Terminated:
                 WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 0, "Workflow Runtime: WorkflowExecutor: attempt to load a completed/terminated instance: {0}", new object[] { this.InstanceIdString });
                 throw new InvalidOperationException(ExecutionStringManager.InvalidAttemptToLoad);
         }
         this._resourceManager = new VolatileResourceManager();
         this._runtime = this._workflowInstance.WorkflowRuntime;
         Queue<Activity> queue = new Queue<Activity>();
         queue.Enqueue(this.rootActivity);
         while (queue.Count > 0)
         {
             Activity dynamicActivity = queue.Dequeue();
             ((IDependencyObjectAccessor) dynamicActivity).InitializeInstanceForRuntime(this);
             this.RegisterDynamicActivity(dynamicActivity, true);
             IList<Activity> list = (IList<Activity>) dynamicActivity.GetValue(Activity.ActiveExecutionContextsProperty);
             if (list != null)
             {
                 foreach (Activity activity2 in list)
                 {
                     queue.Enqueue(activity2);
                 }
             }
         }
     }
     this.isInstanceIdle = (bool) this.rootActivity.GetValue(IsIdleProperty);
     this.RefreshWorkflowDefinition();
 }
 internal void Initialize(Activity rootActivity, WorkflowExecutor invokerExec, string invokeActivityID, Guid instanceId, IDictionary<string, object> namedArguments, System.Workflow.Runtime.WorkflowInstance workflowInstance)
 {
     this.rootActivity = rootActivity;
     this.InstanceId = instanceId;
     this.rootActivity.SetValue(ContextIdProperty, 0);
     this.rootActivity.SetValue(WorkflowInstanceIdProperty, instanceId);
     this.WorkflowStatus = System.Workflow.Runtime.WorkflowStatus.Created;
     this.rootActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, new ActivityExecutionContextInfo(this.rootActivity.QualifiedName, this.GetNewContextId(), instanceId, -1));
     this.rootActivity.SetValue(Activity.ActivityContextGuidProperty, instanceId);
     this.rootActivity.SetValue(IsIdleProperty, true);
     this.isInstanceIdle = true;
     this.rootActivity.SetValue(WorkflowExecutorProperty, this);
     this.RefreshWorkflowDefinition();
     Activity workflowDefinition = this.WorkflowDefinition;
     if (workflowDefinition == null)
     {
         throw new InvalidOperationException("workflowDefinition");
     }
     ((IDependencyObjectAccessor) this.rootActivity).InitializeActivatingInstanceForRuntime(null, this);
     this.rootActivity.FixUpMetaProperties(workflowDefinition);
     this._runtime = workflowInstance.WorkflowRuntime;
     if (invokerExec != null)
     {
         List<string> list = new List<string>();
         System.Workflow.Runtime.TrackingCallingState state = (System.Workflow.Runtime.TrackingCallingState) invokerExec.rootActivity.GetValue(TrackingCallingStateProperty);
         if ((state != null) && (state.CallerActivityPathProxy != null))
         {
             foreach (string str in state.CallerActivityPathProxy)
             {
                 list.Add(str);
             }
         }
         list.Add(invokeActivityID);
         System.Workflow.Runtime.TrackingCallingState state2 = new System.Workflow.Runtime.TrackingCallingState {
             CallerActivityPathProxy = list,
             CallerWorkflowInstanceId = invokerExec.InstanceId,
             CallerContextGuid = ((ActivityExecutionContextInfo) ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid
         };
         if (invokerExec.CurrentActivity.Parent == null)
         {
             state2.CallerParentContextGuid = state2.CallerContextGuid;
         }
         else
         {
             state2.CallerParentContextGuid = ((ActivityExecutionContextInfo) ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity.Parent).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
         }
         this.rootActivity.SetValue(TrackingCallingStateProperty, state2);
     }
     this._setInArgsOnCompanion(namedArguments);
     this.schedulingContext = new System.Workflow.Runtime.Scheduler(this, true);
     this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
     this.qService = new WorkflowQueuingService(this);
     this._workflowInstance = workflowInstance;
     this.TimerQueue = new TimerEventSubscriptionCollection(this, this.InstanceId);
     using (new ServiceEnvironment(this.rootActivity))
     {
         using (this.SetCurrentActivity(this.rootActivity))
         {
             this.RegisterDynamicActivity(this.rootActivity, false);
         }
     }
 }
        protected override void OnActivityExecutionContextLoad(IServiceProvider provider)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.AsyncCreateResourceOnActivityExecutionContextLoad);

            try
            {
                // Ideally we would set CallContext in OnActivityExecutionContextLoad instead here in Execute
                // as OnActivityExecutionContextLoad gets called on each hydration and rehydration of the workflow instance
                // but looks like it's invoked on a different thread context than the rest of the workflow instance execution.
                // To minimize the loss of the CallContext on rehydration, we'll set it in the Execute of every WAL child activities.
                // It will still get lost (momentarily) when the workflow is persisted in the middle of the execution of a replicator activity, for example.
                Logger.SetContextItem(this, this.WorkflowInstanceId);

                base.OnActivityExecutionContextLoad(provider);

                // Load the data access service via reflection
                Assembly assembly = Assembly.GetAssembly(typeof(UpdateResourceActivity));

                const string TypeName = "Microsoft.ResourceManagement.Workflow.Runtime.DataAccessService";
                this.dataAccessServiceType = assembly.GetType(TypeName);
                if (this.dataAccessServiceType == null)
                {
                    throw Logger.Instance.ReportError(new WorkflowActivityLibraryException(Messages.DataAccessService_TypeLoadingFailedError, TypeName));
                }

                this.dataAccessService = provider.GetService(this.dataAccessServiceType);
                this.queuingService = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService));
            }
            finally
            {
                Logger.Instance.WriteMethodExit(EventIdentifier.AsyncCreateResourceOnActivityExecutionContextLoad);
            }
        }
 private void RemoveMessageArrivedEventHandler(WorkflowQueuingService handler)
 {
     lock (this.SyncRoot)
     {
         if (this.messageArrivalEventHandlers != null)
         {
             this.messageArrivalEventHandlers.Remove(handler);
         }
         if (this.dirtyQueues != null)
         {
             foreach (IComparable comparable in this.dirtyQueues)
             {
                 this.GetQueue(comparable).Dirty = false;
             }
         }
     }
 }
        /// <summary>
        /// Creates the workflow program queue.
        /// </summary>
        /// <param name="workflowQueuingService">The workflow queuing service.</param>
        /// <param name="activity">The activity to be used for deriving the queue name.</param>
        /// <returns>The <see cref="WorkflowQueue"/> object.</returns>
        private static WorkflowQueue CreateWorkflowProgramQueue(WorkflowQueuingService workflowQueuingService, Activity activity)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.AsyncUpdateResourceCreateWorkflowProgramQueue);

            try
            {
                string queueName = string.Format(CultureInfo.InvariantCulture, "{0}/{1}", activity.QualifiedName, Guid.NewGuid());

                Logger.Instance.WriteVerbose(EventIdentifier.AsyncUpdateResourceCreateWorkflowProgramQueue, "AsynchronousUpdateResource workflow queue name is: '{0}'.", queueName);

                return workflowQueuingService.CreateWorkflowQueue(queueName, false);
            }
            finally
            {
                Logger.Instance.WriteMethodExit(EventIdentifier.AsyncUpdateResourceCreateWorkflowProgramQueue);
            } 
        }
        private void RemoveMessageArrivedEventHandler(WorkflowQueuingService handler)
        {
            lock (SyncRoot)
            {
                if (this.messageArrivalEventHandlers != null)
                    this.messageArrivalEventHandlers.Remove(handler);

                if (this.dirtyQueues != null)
                {
                    foreach (IComparable queueName in this.dirtyQueues)
                    {
                        EventQueueState qState = GetQueue(queueName);
                        qState.Dirty = false;
                    }
                }
            }
        }
        /// <summary>
        /// Deletes the workflow program queue.
        /// </summary>
        /// <param name="workflowQueuingService">The workflow queuing service.</param>
        /// <param name="queue">The queue name.</param>
        private static void DeleteWorkflowProgramQueue(WorkflowQueuingService workflowQueuingService, WorkflowQueue queue)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.AsyncUpdateResourceDeleteWorkflowProgramQueue);

            try
            {
                if (workflowQueuingService.Exists(queue.QueueName))
                {
                    workflowQueuingService.DeleteWorkflowQueue(queue.QueueName);

                    Logger.Instance.WriteVerbose(EventIdentifier.AsyncUpdateResourceDeleteWorkflowProgramQueue, "AsynchronousUpdateResource deleted workflow queue: '{0}'.", queue.QueueName);
                }
            }
            finally
            {
                Logger.Instance.WriteMethodExit(EventIdentifier.AsyncUpdateResourceDeleteWorkflowProgramQueue);
            } 
        }
Ejemplo n.º 18
0
        void PrivateInitialize(Activity rootActivity, Guid instanceId, IList<PropertyInfo> outputProperties, Activity workflowDefinition)
        {
            this.instanceId = instanceId;
            this.rootActivity = rootActivity;
            this.contextActivityMap = new Dictionary<int, Activity>();
            this.scheduler = new Scheduler(this);
            this.workflowQueuingService = new WorkflowQueuingService(this);
            this.outputProperties = outputProperties;
            this.resourceManager = new VolatileResourceManager();

            this.rootActivity.SetValue(System.Workflow.ComponentModel.Activity.WorkflowDefinitionProperty, workflowDefinition);
            this.rootActivity.SetValue(WorkflowExecutor.WorkflowExecutorProperty, this);
        }