public WorkflowInstance(IWorkflowHost host, Activity workflowDefinition, WorkflowIdentity definitionIdentity)
: base(workflowDefinition, definitionIdentity)
{
this.host = host;
SynchronizationContext = new SynchronizationContext();
}
protected virtual IDictionary <string, object> ExecuteWorkflow(WorkflowIdentity identity,
IDictionary <string, object> inputs, TimeSpan?timeout)
{
return(timeout.HasValue
? _workflowService.Run(identity, inputs, timeout.Value)
: _workflowService.Run(identity, inputs));
}
public void QueueState_should_be_error_when_content_wf_exception()
{
var contentWfName = "I_THROW_EXCEPTION";
var sessionShareExtention = new SessionShareExtention();
var customActivity = new CustomActivity(Error);
var wfIdentity = new WorkflowIdentity(contentWfName, new Version(WfVersion), WfPackageName);
var wfAppFactory = GetWfFactory(wfIdentity, customActivity);
using (var childContainer = _container.CreateChildContainer())
{
childContainer.RegisterInstance <IWorkflowApplicationFactory>(wfAppFactory);
childContainer.RegisterInstance(sessionShareExtention);
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
sessionShareExtention.SharedSession = session;
var queueIn = CreateQueueIn(session);
session.Save(queueIn);
var inputs = new Dictionary <string, object>
{
{ "ContentWorkflowIdentity", GetWfFullName(contentWfName) },
{ "MandantCode", queueIn.Mandant.PartnerCode },
{ "QueueMessageTypeCode", queueIn.QueueMessageType.Code }
};
var service = childContainer.Resolve <TestWorkflowService>();
service.Run(_mainDoWhileWfIdentity, inputs);
queueIn.QueueMessageState.Should().Be(QueueMessageStates.Error);
transaction.Rollback();
}
}
}
public Activity this[WorkflowIdentity definitionIdentity]
{
get
{
return(ActivityPersistenceHelper.LoadActivity(InstanceDefinitions[definitionIdentity]));
}
}
static WorkflowVersionMap()
{
map = new Dictionary<WorkflowIdentity, Activity>();
// Add the current workflow version identities.
StateMachineNumberGuessIdentity = new WorkflowIdentity
{
Name = "StateMachineNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
FlowchartNumberGuessIdentity = new WorkflowIdentity
{
Name = "FlowchartNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
SequentialNumberGuessIdentity = new WorkflowIdentity
{
Name = "SequentialNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
map.Add(StateMachineNumberGuessIdentity, new StateMachineNumberGuessWorkflow());
map.Add(FlowchartNumberGuessIdentity, new FlowchartNumberGuessWorkflow());
map.Add(SequentialNumberGuessIdentity, new SequentialNumberGuessWorkflow());
}
static WorkflowVersionMap()
{
map = new Dictionary <WorkflowIdentity, Activity>();
// Add the current workflow version identities.
StateMachineNumberGuessIdentity = new WorkflowIdentity
{
Name = "StateMachineNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
FlowchartNumberGuessIdentity = new WorkflowIdentity
{
Name = "FlowchartNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
SequentialNumberGuessIdentity = new WorkflowIdentity
{
Name = "SequentialNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
//map.Add(StateMachineNumberGuessIdentity, new StateMachineNumberGuessWorkflow());
map.Add(FlowchartNumberGuessIdentity, new FlowchartNumberGuessWorkflow());
map.Add(SequentialNumberGuessIdentity, new SequentialNumberGuessWorkflow());
}
private WorkflowDefinition(String name, String definition)
{
Name = name;
Definition = definition;
Type = WorkflowType.Definition;
Identity = new WorkflowIdentity(Name, new Version(Version, 0), null);
}
private static WorkflowApplicationInstance GetADummyWorkflowApplicationInstance()
{
WorkflowIdentity wfIdentity = new WorkflowIdentity("GetAWorkflowApplicationInstanceParameter", new Version(1, 0), null);
TestSequence wfDefinition = new TestSequence()
{
Activities =
{
new TestWriteLine("testWriteLine1", "In TestWriteLine1"),
new TestReadLine <string>("ReadLine1", "testReadLine1"),
new TestWriteLine("testWriteLine2", "In TestWriteLine2")
},
};
WorkflowApplicationInstance waInstance;
JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
using (TestWorkflowRuntime workflowRuntime = TestRuntime.CreateTestWorkflowRuntime(wfDefinition, null, jsonStore, PersistableIdleAction.Unload))
{
//PersistenceProviderHelper pphelper = new PersistenceProviderHelper(workflowRuntime.PersistenceProviderFactoryType);
//InstanceStore store = pphelper.CreateWorkflowInstanceStore();
workflowRuntime.ExecuteWorkflow();
workflowRuntime.WaitForIdle();
workflowRuntime.UnloadWorkflow();
workflowRuntime.WaitForUnloaded();
Guid worklfowInstanceId = workflowRuntime.CurrentWorkflowInstanceId;
waInstance = WorkflowApplication.GetInstance(worklfowInstanceId, jsonStore);
waInstance.Abandon();
}
return(waInstance);
}
public Activity this[WorkflowIdentity definitionIdentity]
{
get
{
Activity activity = null;
var found = InstanceDefinitions.TryGetValue(definitionIdentity, out activity);
if (found)
{
return(activity);
}
var assemblyFullName = definitionIdentity.Package;
var activityTypeName = definitionIdentity.Name;
System.Diagnostics.Trace.Assert(assemblyFullName.Contains(definitionIdentity.Version.ToString()));
var objectHandle = Activator.CreateInstance(assemblyFullName, activityTypeName);//tons of exceptions needed to be handled in production
activity = objectHandle.Unwrap() as Activity;
if (activity == null)
{
throw new InvalidOperationException("You must have been crazy.");
}
InstanceDefinitions.TryAdd(definitionIdentity, activity);
return(activity);
}
}
private WorkflowDefinition(String source)
{
// clr:A2.Workflows
// file:fullName
Source = source.Trim();
if (Source.StartsWith("clr:"))
{
var(assembly, type) = ClrHelpers.ParseClrType(source);
Name = type;
Assembly = assembly;
}
else if (Source.StartsWith("file:"))
{
Type = WorkflowType.File;
Path = Source.Substring(5).Trim();
Name = System.IO.Path.GetFileNameWithoutExtension(Path);
}
else if (Source.StartsWith("db:"))
{
Type = WorkflowType.Db;
Path = Source.Substring(3).Trim();
Name = System.IO.Path.GetFileNameWithoutExtension(Path);
}
else
{
throw new WorkflowException($"Invalid workflow source ('{Source}')");
}
Identity = new WorkflowIdentity(Name, new Version(Version, 0), null);
}
public void Dont_do_anything_when_bad_input_parameters()
{
var contentWfName = "I_DONT_MAKE_PROBLEMS";
var sessionShareExtention = new SessionShareExtention();
var customActivity = new CustomActivity();
var wfIdentity = new WorkflowIdentity(contentWfName, new Version(WfVersion), WfPackageName);
var wfAppFactory = GetWfFactory(wfIdentity, customActivity);
using (var childContainer = _container.CreateChildContainer())
{
childContainer.RegisterInstance <IWorkflowApplicationFactory>(wfAppFactory);
childContainer.RegisterInstance(sessionShareExtention);
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
sessionShareExtention.SharedSession = session;
var inputs = new Dictionary <string, object>
{
{ "ContentWorkflowIdentity", GetWfFullName(contentWfName) },
{ "MandantCode", "NotExistingMandantCode" },
{ "QueueMessageTypeCode", "NotExistingQueueMessageTypeCode" }
};
var service = childContainer.Resolve <TestWorkflowService>();
service.Run(_mainDoWhileWfIdentity, inputs);
customActivity.IsExecuted.Should().BeFalse();
transaction.Rollback();
}
}
}
private static WorkflowApplication CreateWorkflow(InstanceStore store, WorkflowApps appType = WorkflowApps.App1)
{
var identity = new WorkflowIdentity {
Name = appType.ToString(), Version = new Version(1, 0),
};
Activity activity = new WorkflowApp1();
if (appType == WorkflowApps.App2)
{
activity = new WorkflowApp2();
}
var whoAmI = new PP(appType);
var app = new WorkflowApplication(activity, identity)
{
InstanceStore = store
};
app.Extensions.Add(whoAmI);
SetEvents(app);
return(app);
}
public void TestWaitForSignalOrDelayVersion2()
{
var a = new WaitForSignalOrAlarm()
{
AlarmTime = DateTime.Now.AddSeconds(10),
BookmarkName = "Wakeup",
};
var definitionIdentity = new WorkflowIdentity("WaitForSignalOrDelay", new Version(2, 0), null);
AutoResetEvent syncEvent = new AutoResetEvent(false);
bool completed1 = false;
bool unloaded1 = false;
var app = new WorkflowApplication(a, definitionIdentity)
{
InstanceStore = WFDefinitionStore.Instance.Store,
PersistableIdle = (eventArgs) =>
{
return(PersistableIdleAction.Unload);
},
OnUnhandledException = (e) =>
{
return(UnhandledExceptionAction.Abort);
},
Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
completed1 = true;
syncEvent.Set();
},
Unloaded = (eventArgs) =>
{
unloaded1 = true;
syncEvent.Set();
},
};
var id = app.Id;
app.Run();
syncEvent.WaitOne();
Assert.False(completed1);
Assert.True(unloaded1);
WFDefinitionIdentityStore.Instance.TryAdd(definitionIdentity, a);
Thread.Sleep(5000); // from 1 seconds to 9 seconds, the total time of the test case is the same.
var outputs = LoadAndCompleteLongRunning(id, definitionIdentity);
Assert.False((bool)outputs["Result"]);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string valueString)
{
return(WorkflowIdentity.Parse(valueString));
}
return(base.ConvertFrom(context, culture, value));
}
public static void Trace(Guid workflowInstanceId, WorkflowIdentity workflowDefinitionIdentity, WorkflowInstanceState state)
{
WorkflowInstanceTrace trace = new WorkflowInstanceTrace(workflowInstanceId, workflowDefinitionIdentity, state);
TraceSource ts = new TraceSource("CoreWf.Tracking", SourceLevels.Information);
ts.TraceData(TraceEventType.Information, 1, trace);
}
public WorkflowManager(Activity wfDefinition, Version vrsn)
{
SqlWorkflowInstanceStore wfInstanceStore = InitializeInstanceStore();
WorkflowIdentity wfIdentity = InitializeIdentity(wfDefinition, vrsn);
this.WFApplication = InitializeApplication(wfDefinition, wfIdentity, wfInstanceStore);
}
/// <summary>
/// Creates the application instance with event handlers. Workflow must accept 'DataEventArgument' as a parameter of type DataEventArgs
/// Relies on: PersistanceHelper.WorkflowHostTypePropertyName, PersistanceHelper.HostTypeName, PersistanceHelper.Store
/// </summary>
/// <param name="activity"></param>
/// <param name="identity"></param>
/// <param name="args"></param>
/// <remarks>DO NOT get the ID of the workflow instance before it's used otherwise on unpersisted workflows they will not work.</remarks>
/// <exception cref="InvalidOperationException"></exception>
/// <exception cref="ArgumentNullException"></exception>
public ApplicationHelper(Activity activity, WorkflowIdentity identity, DataEventArgs args = null) :
this(activity, identity,
//Supply null arguments if they are passed in as null. Other wise default
args == null ? null : new Dictionary <string, object> {
{ DataEventArgumentName, args }
})
{
}
public bool TryAdd <T>(WorkflowIdentity definitionIdentity, ActivityBuilder <T> ab)
{
using (MemoryStream stream = new MemoryStream())
{
ActivityPersistenceHelper.SaveActivity(ab, stream);
stream.Position = 0;
return(InstanceDefinitions.TryAdd(definitionIdentity, stream.ToArray()));
}
}
private WorkflowIdentity InitializeIdentity(Activity wfDefinition, Version vrsn)
{
WorkflowIdentity identity = new WorkflowIdentity();
identity.Name = wfDefinition.DisplayName;
identity.Version = vrsn;
return(identity);
}
internal static Activity GetWorkflow(WorkflowIdentity workflowIdentity)
{
if (_map.ContainsKey(workflowIdentity))
{
return(_map[workflowIdentity]);
}
throw new ArgumentException(workflowIdentity.Name);
}
internal WorkflowApplicationInstance(
WorkflowApplication.PersistenceManagerBase persistenceManager,
IDictionary<XName, InstanceValue> values,
WorkflowIdentity definitionIdentity)
{
this.PersistenceManager = persistenceManager;
this.Values = values;
this.DefinitionIdentity = definitionIdentity;
this.state = (int)State.Initialized;
}
protected WorkflowInstance(Activity workflowDefinition, WorkflowIdentity definitionIdentity)
{
if (workflowDefinition == null)
{
throw FxTrace.Exception.ArgumentNull("workflowDefinition");
}
this.WorkflowDefinition = workflowDefinition;
this.DefinitionIdentity = definitionIdentity;
}
public void Update(Guid instanceId, WorkflowIdentity updatedDefinitionIdentity)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedUpdate(instanceId, updatedDefinitionIdentity);
}
else
{
base.Channel.Update(instanceId, updatedDefinitionIdentity);
}
}
private WorkflowApplicationFactory GetWfFactory(WorkflowIdentity wfIdentity, Activity wf, bool loadContentWf = true)
{
var mockWfStorage = new Mock <IWorkflowStorage>();
mockWfStorage.Setup(i => i.Load(_mainDoWhileWfIdentity)).Returns(new INTEGRATION_IN_MAIN());
if (loadContentWf)
{
mockWfStorage.Setup(i => i.Load(wfIdentity)).Returns(wf);
}
return(new WorkflowApplicationFactory(null as InstanceStore, mockWfStorage.Object));
}
public Guid StartNewInstance(String modelName)
{
WorkflowIdentity workflowIdentity = new WorkflowIdentity("Process1", new Version(0, 1), "wf");
var wf = this.GetExtension <IWorkflowModelCatalog>()?.GetActiveModel("Process1");
var app = new WorkflowApplication(wf);
EnrichWorkflowApplication(app);
app.Run();
lastid = app.Id;
Console.WriteLine(lastid);
return(app.Id);
}
public void UpdateAsync(Guid instanceId, WorkflowIdentity updatedDefinitionIdentity, object userState)
{
if (this.onBeginUpdateDelegate == null)
{
this.onBeginUpdateDelegate = new BeginOperationDelegate(OnBeginUpdate);
this.onEndUpdateDelegate = new EndOperationDelegate(OnEndUpdate);
this.onUpdateCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnUpdateCompleted));
}
base.InvokeAsync(this.onBeginUpdateDelegate, new object[] { instanceId, updatedDefinitionIdentity },
this.onEndUpdateDelegate, this.onUpdateCompleteDelegate, userState);
}
//Compare identities and returns true if they are equal otherwise false
public static bool CompareIdentities(WorkflowIdentity baseIdentity, WorkflowIdentity identity)
{
if (baseIdentity == null && identity == null)
{
return(true);
}
else if (baseIdentity == null || identity == null) //Either one of them is null
{
return(false);
}
return(baseIdentity.Equals(identity) || object.Equals(baseIdentity, identity));
}
private void NewGame_Click(object sender, EventArgs e)
{
var inputs = new Dictionary <string, object>();
inputs.Add("MaxNumber", Convert.ToInt32(NumberRange.SelectedItem));
WorkflowIdentity identity = null;
switch (WorkflowType.SelectedItem.ToString())
{
case "SequentialNumberGuessWorkflow":
identity = WorkflowVersionMap.SequentialNumberGuessIdentity;
break;
case "StateMachineNumberGuessWorkflow":
identity = WorkflowVersionMap.StateMachineNumberGuessIdentity;
break;
case "FlowchartNumberGuessWorkflow":
identity = WorkflowVersionMap.FlowchartNumberGuessIdentity;
break;
case "SequentialNumberGuessWorkflow v1":
identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1;
break;
case "StateMachineNumberGuessWorkflow v1":
identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1;
break;
case "FlowchartNumberGuessWorkflow v1":
identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1;
break;
}
;
Activity wf = WorkflowVersionMap.GetWorkflowDefinition(identity);
WorkflowApplication wfApp = new WorkflowApplication(wf, inputs, identity);
// Add the workflow to the list and display the version information.
WorkflowStarting = true;
InstanceId.SelectedIndex = InstanceId.Items.Add(wfApp.Id);
WorkflowVersion.Text = identity.ToString();
WorkflowStarting = false;
// Configure the instance store, extensions, and
// workflow lifecycle handlers.
ConfigureWorkflowApplication(wfApp);
// Start the workflow.
wfApp.Run();
}
public static void PersistAndUpdate(this TestWorkflowRuntime twRuntime, WorkflowIdentity updatedIdentity)
{
twRuntime.PersistWorkflow();
twRuntime.UnloadWorkflow();
if (null != updatedIdentity)
{
twRuntime.LoadAndUpdateWorkflow(updatedIdentity.ToString());
}
else
{
twRuntime.LoadWorkflow();
}
twRuntime.ResumeWorkflow();
}
private void NewGame_Click(object sender, EventArgs e)
{
var inputs = new Dictionary <string, object>
{
{ "MaxNumber", Convert.ToInt32(NumberRange.SelectedItem) }
};
WorkflowIdentity identity = null;
switch (WorkflowType.SelectedItem.ToString())
{
case "SequentialNumberGuessWorkflow":
identity = WorkflowVersionMap.SequentialNumberGuessIdentity;
break;
case "StateMachineNumberGuessWorkflow":
identity = WorkflowVersionMap.StateMachineNumberGuessIdentity;
break;
case "FlowchartNumberGuessWorkflow":
identity = WorkflowVersionMap.FlowchartNumberGuessIdentity;
break;
case "SequentialNumberGuessWorkflow v1":
identity = WorkflowVersionMap.SequentialNumberGuessIdentity_v1;
break;
case "StateMachineNumberGuessWorkflow v1":
identity = WorkflowVersionMap.StateMachineNumberGuessIdentity_v1;
break;
case "FlowchartNumberGuessWorkflow v1":
identity = WorkflowVersionMap.FlowchartNumberGuessIdentity_v1;
break;
}
;
Activity wf = WorkflowVersionMap.GetWorkflowDefinition(identity);
WorkflowApplication wfApp = new WorkflowApplication(wf, inputs, identity);
WorkflowStarting = true;
InstanceId.SelectedIndex = InstanceId.Items.Add(wfApp.Id);
WorkflowVersion.Text = identity.ToString();
WorkflowStarting = false;
ConfigureWorkflowApplication(wfApp);
wfApp.Run();
}
/// <summary>
/// Creates the application instance with event handlers. Not using the DataEventArgument will prevent transaction id's from propagating through log4net.
/// Relies on: PersistanceHelper.WorkflowHostTypePropertyName, PersistanceHelper.HostTypeName, PersistanceHelper.Store
/// </summary>
/// <param name="activity"></param>
/// <param name="identity"></param>
/// <param name="extensibleArguments">Optional if reloading the workflow. Only required on inital trigger. KVP of argument name and value.</param>
/// <remarks>DO NOT get the ID of the workflow instance before it's used otherwise on unpersisted workflows they will not work.</remarks>
/// <exception cref="InvalidOperationException"></exception>
/// <exception cref="ArgumentNullException"></exception>
public ApplicationHelper(Activity activity, WorkflowIdentity identity, Dictionary <string, object> extensibleArguments)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (PersistanceHelper.Store == null)
{
throw new InvalidOperationException("PersistanceHelper.Store is not set. ");
}
if (extensibleArguments == null)
{
//This should only be used when the workflow is reconstitued.
_application = new WorkflowApplication(activity, identity);
}
else
{
_application = new WorkflowApplication(
activity,
extensibleArguments,
identity);
}
//Owner of the workflow activity
Dictionary <XName, object> wfScope = new Dictionary <XName, object>
{
{
PersistanceHelper.WorkflowHostTypePropertyName,
PersistanceHelper.HostTypeName
}
};
_application.InstanceStore = PersistanceHelper.Store;
_application.OnUnhandledException = UnhandledExceptionEvent;
_application.PersistableIdle = AbleToPersistEvent;
_application.Completed = CompletedEvent;
_application.Unloaded = UnloadedEvent;
_application.Aborted = AbortedEvent;
_application.Idle = IdleEvent;
// Add the WorkflowHostType value to workflow application so that it stores this data in the instance store when persisted
_application.AddInitialInstanceValues(wfScope);
}
private void Start(Func <WorkflowIdentity, Activity> workflowMap,
WorkflowIdentity workflowIdentity, IDictionary <string, object> inputs)
{
// >>>> START A WORKFLOW <<<<
Activity workflow = workflowMap(workflowIdentity);
WorkflowApplication wfApp = new WorkflowApplication(workflow, inputs, workflowIdentity);
// Configure the instance store, extensions, and
// workflow lifecycle handlers.
ConfigureWorkflowApplication(wfApp);
// Start the workflow.
wfApp.Run();
}
private static string GetMessage(WorkflowIdentity expectedVersion, WorkflowIdentity actualVersion)
{
if (actualVersion == null && expectedVersion != null)
{
return SR.WorkflowIdentityNullStateId(expectedVersion);
}
else if (actualVersion != null && expectedVersion == null)
{
return SR.WorkflowIdentityNullHostId(actualVersion);
}
else if (!object.Equals(expectedVersion, actualVersion))
{
return SR.WorkflowIdentityStateIdHostIdMismatch(actualVersion, expectedVersion);
}
else
{
return null;
}
}
static WorkflowVersionMap()
{
map = new Dictionary<WorkflowIdentity, Activity>();
// Add the current workflow version identities.
StateMachineNumberGuessIdentity = new WorkflowIdentity
{
Name = "StateMachineNumberGuessWorkflow",
Version = new Version(2, 0, 0, 0)
};
FlowchartNumberGuessIdentity = new WorkflowIdentity
{
Name = "FlowchartNumberGuessWorkflow",
Version = new Version(2, 0, 0, 0)
};
SequentialNumberGuessIdentity = new WorkflowIdentity
{
Name = "SequentialNumberGuessWorkflow",
Version = new Version(2, 0, 0, 0)
};
map.Add(StateMachineNumberGuessIdentity, new StateMachineNumberGuessWorkflow());
map.Add(FlowchartNumberGuessIdentity, new FlowchartNumberGuessWorkflow());
map.Add(SequentialNumberGuessIdentity, new SequentialNumberGuessWorkflow());
// Initialize the previous workflow version identities.
StateMachineNumberGuessIdentity_v1 = new WorkflowIdentity
{
Name = "StateMachineNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
FlowchartNumberGuessIdentity_v1 = new WorkflowIdentity
{
Name = "FlowchartNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
SequentialNumberGuessIdentity_v1 = new WorkflowIdentity
{
Name = "SequentialNumberGuessWorkflow",
Version = new Version(1, 0, 0, 0)
};
// Add the previous version workflow identities to the dictionary along with
// the corresponding workflow definitions loaded from the v1 assembly.
// Assembly.LoadFile requires an absolute path so convert this relative path
// to an absolute path.
string v1AssemblyPath = @"..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v1.dll";
v1AssemblyPath = Path.GetFullPath(v1AssemblyPath);
Assembly v1Assembly = Assembly.LoadFile(v1AssemblyPath);
map.Add(StateMachineNumberGuessIdentity_v1, v1Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow") as Activity);
map.Add(SequentialNumberGuessIdentity_v1, v1Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow") as Activity);
map.Add(FlowchartNumberGuessIdentity_v1, v1Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow") as Activity);
// Initialize the dynamic update workflow identities.
StateMachineNumberGuessIdentity_v15 = new WorkflowIdentity
{
Name = "StateMachineNumberGuessWorkflow",
Version = new Version(1, 5, 0, 0)
};
FlowchartNumberGuessIdentity_v15 = new WorkflowIdentity
{
Name = "FlowchartNumberGuessWorkflow",
Version = new Version(1, 5, 0, 0)
};
SequentialNumberGuessIdentity_v15 = new WorkflowIdentity
{
Name = "SequentialNumberGuessWorkflow",
Version = new Version(1, 5, 0, 0)
};
// Add the dynamic update workflow identities to the dictionary along with
// the corresponding workflow definitions loaded from the v15 assembly.
// Assembly.LoadFile requires an absolute path so convert this relative path
// to an absolute path.
string v15AssemblyPath = @"..\..\..\PreviousVersions\NumberGuessWorkflowActivities_v15.dll";
v15AssemblyPath = Path.GetFullPath(v15AssemblyPath);
Assembly v15Assembly = Assembly.LoadFile(v15AssemblyPath);
map.Add(StateMachineNumberGuessIdentity_v15, v15Assembly.CreateInstance("NumberGuessWorkflowActivities.StateMachineNumberGuessWorkflow") as Activity);
map.Add(SequentialNumberGuessIdentity_v15, v15Assembly.CreateInstance("NumberGuessWorkflowActivities.SequentialNumberGuessWorkflow") as Activity);
map.Add(FlowchartNumberGuessIdentity_v15, v15Assembly.CreateInstance("NumberGuessWorkflowActivities.FlowchartNumberGuessWorkflow") as Activity);
}
public WorkflowInstanceTerminatedRecord(Guid instanceId, long recordNumber, string activityDefinitionId, string reason, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, recordNumber, activityDefinitionId, reason)
{
this.WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
public WorkflowInstanceAbortedRecord(Guid instanceId, string activityDefinitionId, string reason, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, activityDefinitionId, reason)
{
this.WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
public static string GetIdentityDescription(WorkflowIdentity identity)
{
return identity.ToString();
}
public WorkflowInstanceReminderRecord(Guid instanceId, long recordNumber, string activityDefinitionId, string state, string reminderName, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, recordNumber, activityDefinitionId, state, reminderName)
{
WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
public WorkflowInstanceUnhandledExceptionRecord(Guid instanceId, long recordNumber, string activityDefinitionId, ActivityInfo faultSource, Exception exception, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, recordNumber, activityDefinitionId, faultSource, exception)
{
this.WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
public WorkflowServiceInstance InitializeInstance(Guid instanceId, PersistenceContext context, WorkflowIdentity definitionIdentity, WorkflowIdentityKey updatedIdentity, IDictionary<XName, InstanceValue> instance, WorkflowCreationContext creationContext)
{
Activity workflowDefinition = null;
DynamicUpdateMap updateMap = null;
if (updatedIdentity != null && !object.Equals(updatedIdentity.Identity, definitionIdentity))
{
if (!this.workflowDefinitionProvider.TryGetDefinitionAndMap(definitionIdentity, updatedIdentity.Identity, out workflowDefinition, out updateMap))
{
if (this.workflowDefinitionProvider.TryGetDefinition(updatedIdentity.Identity, out workflowDefinition))
{
throw FxTrace.Exception.AsError(new FaultException(
OperationExecutionFault.CreateUpdateFailedFault(SR.UpdateMapNotFound(definitionIdentity, updatedIdentity.Identity))));
}
else
{
throw FxTrace.Exception.AsError(new FaultException(
OperationExecutionFault.CreateUpdateFailedFault(SR.UpdateDefinitionNotFound(updatedIdentity.Identity))));
}
}
}
else if (!this.workflowDefinitionProvider.TryGetDefinition(definitionIdentity, out workflowDefinition))
{
throw FxTrace.Exception.AsError(new VersionMismatchException(SR.WorkflowServiceDefinitionIdentityNotMatched(definitionIdentity), null, definitionIdentity));
}
WorkflowIdentity definitionToLoad = updatedIdentity == null ? definitionIdentity : updatedIdentity.Identity;
return WorkflowServiceInstance.InitializeInstance(context, instanceId, workflowDefinition, definitionToLoad, instance, creationContext,
WorkflowSynchronizationContext.Instance, this.serviceHost, updateMap);
}
public static WorkflowServiceInstance InitializeInstance(PersistenceContext persistenceContext, Guid instanceId, Activity workflowDefinition, WorkflowIdentity definitionIdentity, IDictionary<XName, InstanceValue> loadedObject, WorkflowCreationContext creationContext,
SynchronizationContext synchronizationContext, WorkflowServiceHost serviceHost, DynamicUpdateMap updateMap = null)
{
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, definitionIdentity, 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;
}
try
{
workflowInstance.Initialize(deserializedRuntimeState, updateMap);
}
catch (InstanceUpdateException)
{
// Need to flush the tracking record for the update failure
workflowInstance.ScheduleAbortTracking(true);
throw;
}
if (updateMap != null)
{
workflowInstance.HasBeenUpdated = true;
}
}
else
{
IList<Handle> rootExecutionProperties = null;
IDictionary<string, object> workflowArguments = null;
// Provide default CorrelationScope if root activity is not CorrelationScope
if (!(workflowDefinition is CorrelationScope))
{
rootExecutionProperties = new List<Handle>(1)
{
new CorrelationHandle()
};
}
if (creationContext != null)
{
workflowArguments = creationContext.RawWorkflowArguments;
workflowInstance.creationContext = creationContext;
}
workflowInstance.Initialize(workflowArguments, rootExecutionProperties);
}
return workflowInstance;
}
WorkflowServiceInstance(Activity workflowDefinition, WorkflowIdentity definitionIdentity, Guid instanceId, WorkflowServiceHost serviceHost, PersistenceContext persistenceContext)
: base(workflowDefinition, definitionIdentity)
{
this.serviceHost = serviceHost;
this.instanceId = instanceId;
this.persistTimeout = serviceHost.PersistTimeout;
this.trackTimeout = serviceHost.TrackTimeout;
this.bufferedReceiveManager = serviceHost.Extensions.Find<BufferedReceiveManager>();
if (persistenceContext != null)
{
this.persistenceContext = persistenceContext;
this.persistenceContext.Closed += this.OnPersistenceContextClosed;
}
this.thisLock = new object();
this.pendingRequests = new List<WorkflowOperationContext>();
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 Guid GetIdentityHash(WorkflowIdentity id)
{
byte[] identityHashBuffer = Encoding.Unicode.GetBytes(id.ToString());
return new Guid(HashHelper.ComputeHash(identityHashBuffer));
}
public WorkflowInstanceRecord(Guid instanceId, string activityDefinitionId, string state, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, activityDefinitionId, state)
{
this.WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
public VersionMismatchException(string message, WorkflowIdentity expectedVersion, WorkflowIdentity actualVersion, Exception innerException)
: base(message, innerException)
{
this.ExpectedVersion = expectedVersion;
this.ActualVersion = actualVersion;
}
public VersionMismatchException(WorkflowIdentity expectedVersion, WorkflowIdentity actualVersion)
: base(GetMessage(expectedVersion, actualVersion))
{
this.ExpectedVersion = expectedVersion;
this.ActualVersion = actualVersion;
}
public WorkflowInstanceUpdatedRecord(Guid instanceId, long recordNumber, string activityDefinitionId, WorkflowIdentity originalDefinitionIdentity, WorkflowIdentity updatedDefinitionIdentity)
: base(instanceId, recordNumber, activityDefinitionId, WorkflowInstanceStates.Updated, updatedDefinitionIdentity)
{
this.OriginalDefinitionIdentity = originalDefinitionIdentity;
}
public WorkflowInstanceUpdatedRecord(Guid instanceId, long recordNumber, string activityDefinitionId, WorkflowIdentity originalDefinitionIdentity, WorkflowIdentity updatedDefinitionIdentity, IList<ActivityBlockingUpdate> blockingActivities)
: base(instanceId, recordNumber, activityDefinitionId, WorkflowInstanceStates.UpdateFailed, updatedDefinitionIdentity)
{
this.OriginalDefinitionIdentity = originalDefinitionIdentity;
this.BlockingActivities = new List<ActivityBlockingUpdate>(blockingActivities).AsReadOnly();
}
static Guid GetIdentityAnyRevisionFilterHash(WorkflowIdentity id)
{
if (id.Version != null)
{
Version version;
if (id.Version.Build >= 0)
{
version = new Version(id.Version.Major, id.Version.Minor, id.Version.Build);
}
else
{
version = new Version(id.Version.Minor, id.Version.Minor);
}
return GetIdentityHash(new WorkflowIdentity(id.Name, version, id.Package));
}
else
{
return GetIdentityHash(id);
}
}
public static Activity GetWorkflowDefinition(WorkflowIdentity identity)
{
return map[identity];
}
public WorkflowInstanceExceptionRecord(Guid instanceId, long recordNumber, string activityDefinitionId, Exception exception, WorkflowIdentity workflowDefinitionIdentity)
: this(instanceId, recordNumber, activityDefinitionId, exception)
{
WorkflowDefinitionIdentity = workflowDefinitionIdentity;
}
