public Bookmark CreateBookmark(BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { Bookmark bookmark = Bookmark.Create(this.GetNextBookmarkId()); this.AddBookmark(bookmark, callback, owningInstance, options); this.UpdateAllExclusiveHandles(bookmark, owningInstance); return bookmark; }
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions bookmarkOptions) : base(callback, owningInstance) { Fx.Assert(callback != null || bookmarkOptions == BookmarkOptions.None, "Either we have a callback or we only allow SingleFire, Blocking bookmarks."); this.Options = bookmarkOptions; }
public void Invoke(NativeActivityContext context, Bookmark bookmark, object value) { EnsureCallback(bookmarkCallbackType, bookmarkCallbackParameters); BookmarkCallback bookmarkCallback = (BookmarkCallback)this.Callback; bookmarkCallback(context, bookmark, value); }
// Token: 0x06001664 RID: 5732 RVA: 0x0002762B File Offset: 0x0002662B public Bookmark(string name, BookmarkCallback bookmarkCallback, BookmarkOptions options, ActivityExecutionContext context) { this.name = name; this.bookmarkCallback = bookmarkCallback; this.options = options; this.context = context; }
public InternalState(State state) { this.state = state; this.DisplayName = state.DisplayName; this.onEntryComplete = new CompletionCallback(OnEntryComplete); this.onTriggerComplete = new CompletionCallback(OnTriggerComplete); this.onConditionComplete = new CompletionCallback <bool>(OnConditionComplete); this.onExitComplete = new CompletionCallback(OnExitComplete); this.onChildStateComplete = new CompletionCallback <string>(OnChildStateComplete); this.completeStateCallback = new BookmarkCallback(CompleteState); this.evaluateConditionCallback = new BookmarkCallback(StartEvaluateCondition); this.currentRunningTriggers = new Variable <int>(); this.hasRunningChildState = new Variable <bool>(); this.isExiting = new Variable <bool>(); this.evaluateConditionBookmark = new Variable <Bookmark>(); this.completeStateBookmark = new Variable <Bookmark>(); this.internalStates = new Collection <InternalState>(); this.internalTransitions = new Collection <InternalTransition>(); this.internalStateFuncs = new Collection <ActivityFunc <string, StateMachineEventManager, string> >(); this.triggerInternalTransitionMapping = new Dictionary <Activity, InternalTransition>(); }
private void CompleteTransactionCore(NativeActivityContext context, BookmarkCallback callback) { context.ThrowIfDisposed(); if (this.rootTransaction != null) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CannotCompleteRuntimeOwnedTransaction)); } if (!context.HasRuntimeTransaction) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NoRuntimeTransactionExists)); } if (!this.isHandleInitialized) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UnInitializedRuntimeTransactionHandle)); } if (this.SuppressTransaction) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RuntimeTransactionIsSuppressed)); } context.CompleteTransaction(this, callback); }
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior) { this.WorkflowCompensationScheduled = context.CreateBookmark(callback); context.ScheduleSecondaryRoot(workflowCompensationBehavior, null); this.Add(0L, new CompensationTokenData(0L, 0L)); this.IsWorkflowCompensationBehaviorScheduled = true; }
public void Invoke(NativeActivityContext context, System.Activities.Bookmark bookmark, object value) { base.EnsureCallback(bookmarkCallbackType, bookmarkCallbackParameters); BookmarkCallback callback = (BookmarkCallback)base.Callback; callback(context, bookmark, value); }
public void CompleteTransaction(NativeActivityContext context, BookmarkCallback callback) { if (callback == null) { throw FxTrace.Exception.ArgumentNull("callback"); } this.CompleteTransactionCore(context, callback); }
public Bookmark CreateBookmark(BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { Bookmark bookmark = Bookmark.Create(this.GetNextBookmarkId()); this.AddBookmark(bookmark, callback, owningInstance, options); this.UpdateAllExclusiveHandles(bookmark, owningInstance); return(bookmark); }
// Token: 0x06001651 RID: 5713 RVA: 0x00027208 File Offset: 0x00026208 public Bookmark CreateNamedBookmark(string name, BookmarkCallback callback, BookmarkOptions options) { Bookmark bookmark = new Bookmark(name, callback, options, this); bookmark.Closed += this.OnBookmarkClosed; this.bookmarks.Add(bookmark); return(bookmark); }
public ReceiveFileChanges() { this.noPersistHandle = new Variable <NoPersistHandle>(); this.receiveCompleteBookmark = new Variable <Bookmark>() { Name = "ReceiveBookmark" }; this.receiveCompleteCallback = new BookmarkCallback(this.OnReceiveNotification); }
public FolderWatcher() { // create the variables to hold the NoPersistHandle and Bookmark this.noPersistHandle = new Variable <NoPersistHandle>(); this.bookmarkWatcher = new Variable <Bookmark>(); this.bookmarkCallback = new BookmarkCallback(OnFileWatcherCallback); this.WatchSubfolders = false; }
public static Bookmark CreateBookmark(this NativeActivityContext context, WaitForTaskAction action, BookmarkCallback callback) { using (StringWriter writer = new StringWriter()) { SERIALIZER.Serialize(writer, action); return context.CreateBookmark(writer.ToString(), callback); } }
public InteropEnvironment(InteropExecutor interopExecutor, NativeActivityContext nativeActivityContext, BookmarkCallback bookmarkCallback, Interop activity, Transaction transaction) { this.executor = interopExecutor; this.nativeActivityContext = nativeActivityContext; this.Activity = activity; this.executor.ServiceProvider = this; this.bookmarkCallback = bookmarkCallback; this.transaction = transaction; this.OnEnter(); }
public Bookmark CreateBookmark(string name, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { Bookmark key = new Bookmark(name); if ((this.bookmarks != null) && this.bookmarks.ContainsKey(key)) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkAlreadyExists(name))); } this.AddBookmark(key, callback, owningInstance, options); this.UpdateAllExclusiveHandles(key, owningInstance); return key; }
public FileCopy() { // add the validation to the list of validations for this activity this.Constraints.Add(ConstraintHelper.VerifiyNoChildPersistActivity <FileCopy>()); // create the variables to hold the NoPersistHandle and Bookmark this.noPersistHandle = new Variable <NoPersistHandle>(); this.bookmarkProgress = new Variable <Bookmark>(); this.bookmarkProgressCallback = new BookmarkCallback(OnExtensionProgress); this.StepIncrement = 1; }
protected override void Execute(NativeActivityContext context) { if (context.IsInNoPersistScope) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotPersistInsideNoPersist)); } if (onPersistCompleteCallback == null) { onPersistCompleteCallback = new BookmarkCallback(Persist.OnPersistComplete); } context.RequestPersist(onPersistCompleteCallback); }
public Bookmark CreateBookmark(string name, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { Bookmark key = new Bookmark(name); if ((this.bookmarks != null) && this.bookmarks.ContainsKey(key)) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BookmarkAlreadyExists(name))); } this.AddBookmark(key, callback, owningInstance, options); this.UpdateAllExclusiveHandles(key, owningInstance); return(key); }
public Bookmark CreateBookmark(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Fx.Assert(this.scope == null, "We only support named bookmarks within bookmark scopes right now."); Bookmark bookmark = Bookmark.Create(GetNextBookmarkId()); AddBookmark(bookmark, callback, owningInstance, options); //Regular bookmarks are never important UpdateAllExclusiveHandles(bookmark, owningInstance); return(bookmark); }
public FileCopy() { // add the validation to the list of validations for this activity this.Constraints.Add(ConstraintHelper.VerifiyNoChildPersistActivity<FileCopy>()); // create the variables to hold the NoPersistHandle and Bookmark this.noPersistHandle = new Variable<NoPersistHandle>(); this.bookmarkProgress = new Variable<Bookmark>(); this.bookmarkProgressCallback = new BookmarkCallback(OnExtensionProgress); this.StepIncrement = 1; }
/// <summary> /// Creates a bookmark name for the given callback. /// </summary> /// <param name="context"></param> /// <param name="callback"></param> /// <returns></returns> public static string CreateTwilioBookmarkName(this NativeActivityContext context, BookmarkCallback callback) { var activity = callback.Target as Activity; if (activity == null) throw new ArgumentException("Callback must be instance method of Activity."); return string.Format("{0}_{1}_{2}_{3}", activity.Id, activity.DisplayName, callback.Method.Name, Math.Abs(Guid.NewGuid().GetHashCode())); }
protected override void Execute(NativeActivityContext context) { if (context.IsInNoPersistScope) { throw Microsoft.CoreWf.Internals.FxTrace.Exception.AsError(new InvalidOperationException(SR.CannotPersistInsideNoPersist)); } if (s_onPersistCompleteCallback == null) { s_onPersistCompleteCallback = new BookmarkCallback(OnPersistComplete); } context.RequestPersist(s_onPersistCompleteCallback); }
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { BookmarkManager manager = null; BookmarkScope key = scope; if (scope.IsDefault) { key = this.defaultScope; } if (!this.bookmarkManagers.TryGetValue(key, out manager)) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RegisteredBookmarkScopeRequired)); } return(manager.CreateBookmark(name, callback, owningInstance, options)); }
public Bookmark CreateBookmark(string name, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Bookmark toAdd = new Bookmark(name); if (this.bookmarks != null && this.bookmarks.ContainsKey(toAdd)) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BookmarkAlreadyExists(name))); } AddBookmark(toAdd, callback, owningInstance, options); //Regular bookmarks are never important UpdateAllExclusiveHandles(toAdd, owningInstance); return(toAdd); }
public InternalState(System.Activities.Statements.State state) { this.state = state; base.DisplayName = state.DisplayName; this.onEntryComplete = new CompletionCallback(this.OnEntryComplete); this.onTriggerComplete = new CompletionCallback(this.OnTriggerComplete); this.onConditionComplete = new CompletionCallback <bool>(this.OnConditionComplete); this.onExitComplete = new CompletionCallback(this.OnExitComplete); this.evaluateConditionCallback = new BookmarkCallback(this.StartEvaluateCondition); this.currentRunningTriggers = new Variable <int>(); this.isExiting = new Variable <bool>(); this.evaluateConditionBookmark = new Variable <Bookmark>(); this.internalTransitions = new Collection <InternalTransition>(); this.triggerInternalTransitionMapping = new Dictionary <Activity, InternalTransition>(); }
public Bookmark CreateBookmark(string name, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Bookmark toAdd = new Bookmark(name); if (this.bookmarks != null && this.bookmarks.ContainsKey(toAdd)) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.BookmarkAlreadyExists(name))); } AddBookmark(toAdd, callback, owningInstance, options); //Regular bookmarks are never important UpdateAllExclusiveHandles(toAdd, owningInstance); return toAdd; }
private void AddBookmark(Bookmark bookmark, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { if (this.bookmarks == null) { this.bookmarks = new Dictionary<Bookmark, BookmarkCallbackWrapper>(Bookmark.Comparer); } bookmark.Scope = this.scope; BookmarkCallbackWrapper wrapper = new BookmarkCallbackWrapper(callback, owningInstance, options) { Bookmark = bookmark }; this.bookmarks.Add(bookmark, wrapper); owningInstance.AddBookmark(bookmark, options); if (TD.CreateBookmarkIsEnabled()) { TD.CreateBookmark(owningInstance.Activity.GetType().ToString(), owningInstance.Activity.DisplayName, owningInstance.Id, ActivityUtilities.GetTraceString(bookmark), ActivityUtilities.GetTraceString(bookmark.Scope)); } }
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Fx.Assert(scope != null, "We should never have a null scope."); var lookupScope = scope; if (scope.IsDefault) { lookupScope = this.defaultScope; } if (!this.bookmarkManagers.TryGetValue(lookupScope, out var manager)) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RegisteredBookmarkScopeRequired)); } return(manager.CreateBookmark(name, callback, owningInstance, options)); }
private void AddBookmark(Bookmark bookmark, BookmarkCallback callback, System.Activities.ActivityInstance owningInstance, BookmarkOptions options) { if (this.bookmarks == null) { this.bookmarks = new Dictionary <Bookmark, BookmarkCallbackWrapper>(Bookmark.Comparer); } bookmark.Scope = this.scope; BookmarkCallbackWrapper wrapper = new BookmarkCallbackWrapper(callback, owningInstance, options) { Bookmark = bookmark }; this.bookmarks.Add(bookmark, wrapper); owningInstance.AddBookmark(bookmark, options); if (TD.CreateBookmarkIsEnabled()) { TD.CreateBookmark(owningInstance.Activity.GetType().ToString(), owningInstance.Activity.DisplayName, owningInstance.Id, ActivityUtilities.GetTraceString(bookmark), ActivityUtilities.GetTraceString(bookmark.Scope)); } }
protected override void Execute(NativeActivityContext executionContext) { CorrelationRequestContext context; CorrelationHandle handle = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext); bool flag = false; CorrelationHandle ambientCorrelation = null; if (handle == null) { ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle; flag = true; if (ambientCorrelation != null) { handle = ambientCorrelation; } } if ((handle != null) && handle.TryAcquireRequestContext(executionContext, out context)) { ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(context); if (flag) { instance.SetAmbientCorrelation(ambientCorrelation); } this.ClientScheduleOnReceivedMessage(executionContext, instance); } else { if (ambientCorrelation == null) { ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle; } if ((!this.IsOneWay && (ambientCorrelation == null)) && (CorrelationHandle.GetExplicitChannelCorrelation(executionContext, this.correlationInitializers) == null)) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName))); } BookmarkScope scope = (handle != null) ? handle.EnsureBookmarkScope(executionContext) : executionContext.DefaultBookmarkScope; if (this.onMessageBookmarkCallback == null) { this.onMessageBookmarkCallback = new BookmarkCallback(this.OnMessage); } executionContext.CreateBookmark(this.OperationBookmarkName, this.onMessageBookmarkCallback, scope); } }
private void CompleteTransactionCore(NativeActivityContext context, BookmarkCallback callback) { context.ThrowIfDisposed(); if (this.rootTransaction != null) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotCompleteRuntimeOwnedTransaction)); } if (!context.HasRuntimeTransaction) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.NoRuntimeTransactionExists)); } if (!this.isHandleInitialized) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.UnInitializedRuntimeTransactionHandle)); } if (this.SuppressTransaction) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RuntimeTransactionIsSuppressed)); } context.CompleteTransaction(this, callback); }
public void Execute(NativeActivityContext context , Func <NativeActivityContext, CancellationToken, Task <Action <NativeActivityContext> > > onExecute , BookmarkCallback callback) { _noPersistHandle.Get(context).Enter(context); Bookmark bookmark = context.CreateBookmark(callback); BookmarkResumptionHelper bookmarkHelper = context.GetExtension <BookmarkResumptionHelper>(); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); _cancellationTokenSource.Set(context, cancellationTokenSource); _bookmarkResumed.Set(context, false); // TODO: Review the continuation. onExecute(context, cancellationTokenSource.Token).ContinueWith(t => { // We resume the bookmark only if the activity wasn't // cancelled since the cancellation removes any bookmarks. if (cancellationTokenSource.IsCancellationRequested == false) { object executionResult = null; if (t.IsFaulted) { executionResult = t.Exception.InnerException; } else { executionResult = t.Result; } bookmarkHelper.ResumeBookmark(bookmark, executionResult); } }); }
internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior) { this.WorkflowCompensationScheduled = context.CreateBookmark(callback); Fx.Assert(workflowCompensationBehavior != null, "WorkflowCompensationBehavior must be valid"); context.ScheduleSecondaryRoot(workflowCompensationBehavior, null); // Add the root compensationToken to track all root CA execution order. this.Add(CompensationToken.RootCompensationId, new CompensationTokenData(CompensationToken.RootCompensationId, CompensationToken.RootCompensationId)); this.IsWorkflowCompensationBehaviorScheduled = true; }
public Bookmark CreateBookmark(string name, BookmarkScope scope, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Fx.Assert(scope != null, "We should never have a null scope."); BookmarkManager manager = null; BookmarkScope lookupScope = scope; if (scope.IsDefault) { lookupScope = this.defaultScope; } if (!this.bookmarkManagers.TryGetValue(lookupScope, out manager)) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RegisteredBookmarkScopeRequired)); } return manager.CreateBookmark(name, callback, owningInstance, options); }
/// <summary> /// Creates a point at which an activity can be resumed. /// </summary> /// <param name="context"></param> /// <param name="callback"></param> /// <returns></returns> public static Bookmark CreateTwilioBookmark(this NativeActivityContext context, BookmarkCallback callback) { return(context.CreateBookmark(CreateTwilioBookmarkName(context, callback), callback)); }
public BookmarkCallbackWrapper(BookmarkCallback callback, ActivityInstance owningInstance) : this(callback, owningInstance, BookmarkOptions.None) { }
public void CompleteTransaction (NativeActivityContext context, BookmarkCallback callback) { throw new NotImplementedException (); }
public void CompleteTransaction(NativeActivityContext context, BookmarkCallback callback) { throw new NotImplementedException(); }
/// <summary> /// Creates a point at which an activity can be resumed. /// </summary> /// <param name="context"></param> /// <param name="callback"></param> /// <returns></returns> public static Bookmark CreateTwilioBookmark(this NativeActivityContext context, BookmarkCallback callback) { return context.CreateBookmark(CreateTwilioBookmarkName(context, callback), callback); }
// Activity Entry point: Phase 1: Execute // A separate code-path for extension based execution least impacts // the existing workflow hosts. In the future we will add an extension from // workflowservicehost and always use the extension. protected override void Execute(NativeActivityContext executionContext) { SendReceiveExtension sendReceiveExtension = executionContext.GetExtension<SendReceiveExtension>(); if (sendReceiveExtension != null) { this.ExecuteUsingExtension(sendReceiveExtension, executionContext); } else { // this activity's runtime DU particpation(UpdateInstance) is dependent on // the following server side logic for resolving CorrelationHandle and creating a protocol bookmark. CorrelationHandle followingCorrelation = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext); bool triedAmbientCorrelation = false; CorrelationHandle ambientCorrelation = null; if (followingCorrelation == null) { ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle; triedAmbientCorrelation = true; if (ambientCorrelation != null) { followingCorrelation = ambientCorrelation; } } CorrelationRequestContext requestContext; if (followingCorrelation != null && followingCorrelation.TryAcquireRequestContext(executionContext, out requestContext)) { // Client receive that is following a send. ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(requestContext); // for perf, cache the ambient correlation information if (triedAmbientCorrelation) { instance.SetAmbientCorrelation(ambientCorrelation); } ClientScheduleOnReceivedMessage(executionContext, instance); } else { // Server side receive // Validation of correlatesWithHandle if (ambientCorrelation == null) { ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle; } if (!this.IsOneWay && ambientCorrelation == null) { CorrelationHandle channelCorrelationHandle = CorrelationHandle.GetExplicitRequestReplyCorrelation(executionContext, this.correlationInitializers); if (channelCorrelationHandle == null) { // With a two-way contract, we require a request/reply correlation handle throw FxTrace.Exception.AsError(new InvalidOperationException( SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName))); } } BookmarkScope bookmarkScope = (followingCorrelation != null) ? followingCorrelation.EnsureBookmarkScope(executionContext) : executionContext.DefaultBookmarkScope; if (this.onMessageBookmarkCallback == null) { this.onMessageBookmarkCallback = new BookmarkCallback(this.OnMessage); } executionContext.CreateBookmark(this.OperationBookmarkName, this.onMessageBookmarkCallback, bookmarkScope); } } }
// Token: 0x06001650 RID: 5712 RVA: 0x000271FC File Offset: 0x000261FC public Bookmark CreateNamedBookmark(string name, BookmarkCallback callback) { return(this.CreateNamedBookmark(name, callback, BookmarkOptions.SingleResume)); }
public Bookmark CreateBookmark(BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { Fx.Assert(this.scope == null, "We only support named bookmarks within bookmark scopes right now."); Bookmark bookmark = Bookmark.Create(GetNextBookmarkId()); AddBookmark(bookmark, callback, owningInstance, options); //Regular bookmarks are never important UpdateAllExclusiveHandles(bookmark, owningInstance); return bookmark; }