private IAsyncResult CreateWorkflowOwner(InstancePersistenceContext context, CreateWorkflowOwnerCommand command, TimeSpan timeout, AsyncCallback callback, object state)
{
var owner = new LockOwner()
{
Id = Guid.NewGuid(),
};
// TODO: map fields into the owner entity
Debug.WriteLine("CreateWorkflowOwner::InstanceOwnerMetadata: ");
Debug.Indent();
foreach (var key in command.InstanceOwnerMetadata.Keys)
{
Debug.WriteLine("[{0}]=[{1}]", key, command.InstanceOwnerMetadata[key].Value);
}
Debug.Unindent();
//context.BindInstanceOwner(owner.Id, owner.Id);
//context.BindEvent(HasRunnableWorkflowEvent.Value);
//return new CompletedAsyncResult(callback, state);
return null;
}
public WorkflowService(
IUsersService users
)
{
_users = users;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
SqlWorkflowInstanceStore store = new SqlWorkflowInstanceStore(_users.ApplicationConnectionString);
_wfApp = new WorkflowApplication(new XODB.Workflow.AssignResponsibility());
_wfApp.InstanceStore = store;
XName wfHostTypeName = XName.Get("XODB", _users.ApplicationID.ToString());
Dictionary<XName, object> wfScope = new Dictionary<XName, object> { { workflowHostTypePropertyName, wfHostTypeName } };
_wfApp.AddInitialInstanceValues(wfScope);
_wfApp.Extensions.Add(new ResponsibilityExtension());
List<XName> variantProperties = new List<XName>()
{
ResponsibilityExtension.xNS.GetName("CompanyID"),
ResponsibilityExtension.xNS.GetName("ContactID")
};
store.Promote("Responsibility", variantProperties, null);
InstanceHandle handle = store.CreateInstanceHandle(null);
var cmd = new CreateWorkflowOwnerCommand
{
InstanceOwnerMetadata =
{
{workflowHostTypePropertyName, new InstanceValue(wfHostTypeName)}
}
};
InstanceOwner owner = store.Execute(handle, cmd, TimeSpan.MaxValue).InstanceOwner;
store.DefaultInstanceOwner = owner;
handle.Free();
_wfApp.PersistableIdle = delegate(WorkflowApplicationIdleEventArgs e)
{
return PersistableIdleAction.Persist;
};
_wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
if (System.Diagnostics.Debugger.IsAttached)
{
foreach (var item in e.Outputs)
{
System.Diagnostics.Debug.WriteLine("Variable:{0} has value: {1}", item.Key, item.Value);
}
}
};
var trackingParticipant = new TrackingHelper.DebugTrackingParticipant
{
TrackingProfile = TrackingHelper.SimpleProfile
};
_wfApp.Extensions.Add(trackingParticipant);
}
internal DurableInstanceManager(WorkflowServiceHost host)
{
this.DurableInstancingOptions = new System.ServiceModel.Activities.DurableInstancingOptions(this);
this.createOwnerCommand = new CreateWorkflowOwnerCommand();
this.instanceMetadataChanges = new Dictionary<XName, InstanceValue>();
this.thisLock = new object();
InstanceValue value2 = new InstanceValue(XNamespace.Get("http://tempuri.org").GetName("Sentinel"));
this.createOwnerCommand.InstanceOwnerMetadata.Add(WorkflowNamespace.WorkflowHostType, value2);
this.instanceMetadataChanges.Add(WorkflowNamespace.WorkflowHostType, value2);
this.instanceMetadataChanges.Add(PersistenceMetadataNamespace.InstanceType, new InstanceValue(WorkflowNamespace.WorkflowHostType, InstanceValueOptions.WriteOnly));
this.Host = host;
}
// Configure a Default Owner for the instance store so instances can be re-loaded from WorkflowApplication
private static InstanceHandle CreateInstanceStoreOwner(InstanceStore store, XName wfHostTypeName)
{
InstanceHandle ownerHandle = store.CreateInstanceHandle();
CreateWorkflowOwnerCommand ownerCommand = new CreateWorkflowOwnerCommand()
{
InstanceOwnerMetadata =
{
{ WorkflowHostTypePropertyName, new InstanceValue(wfHostTypeName) }
}
};
store.DefaultInstanceOwner = store.Execute(ownerHandle, ownerCommand, TimeSpan.FromSeconds(30)).InstanceOwner;
return ownerHandle;
}
IDictionary <XName, InstanceValue> GetCommandMetadata(out bool withIdentity)
{
CreateWorkflowOwnerWithIdentityCommand createOwnerWithIdentityCommand = base.InstancePersistenceCommand as CreateWorkflowOwnerWithIdentityCommand;
if (createOwnerWithIdentityCommand != null)
{
withIdentity = true;
return(createOwnerWithIdentityCommand.InstanceOwnerMetadata);
}
else
{
CreateWorkflowOwnerCommand createOwnerCommand = (CreateWorkflowOwnerCommand)base.InstancePersistenceCommand;
withIdentity = false;
return(createOwnerCommand.InstanceOwnerMetadata);
}
}
private void ExtractWorkflowHostType()
{
InstanceValue value2;
CreateWorkflowOwnerCommand instancePersistenceCommand = (CreateWorkflowOwnerCommand)base.InstancePersistenceCommand;
if (instancePersistenceCommand.InstanceOwnerMetadata.TryGetValue(WorkflowNamespace.WorkflowHostType, out value2))
{
XName name = value2.Value as XName;
if (name == null)
{
throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(System.Activities.DurableInstancing.SR.InvalidWorkflowHostTypeValue(WorkflowNamespace.WorkflowHostType)));
}
byte[] bytes = Encoding.Unicode.GetBytes(name.ToString());
base.Store.WorkflowHostType = new Guid(HashHelper.ComputeHash(bytes));
this.fireRunnableInstancesEvent = true;
}
}
static InstanceStore CreateInstanceStore()
{
string connectionString = ConfigurationManager.ConnectionStrings["InstanceStore"].ConnectionString;
var instanceStore = new SqlWorkflowInstanceStore(connectionString);
var instanceHandle = instanceStore.CreateInstanceHandle();
var ownerCommand = new CreateWorkflowOwnerCommand();
XNamespace hostNamespace = XNamespace.Get("urn:schemas-microsoft-com:System.Activities/4.0/properties");
XName hostKey = hostNamespace.GetName("WorkflowHostType");
var hostValue = new InstanceValue(XNamespace.Get("http://tempuri.org").GetName("SampleInstance"));
ownerCommand.InstanceOwnerMetadata.Add(hostKey, hostValue);
instanceStore.DefaultInstanceOwner = instanceStore.Execute(
instanceHandle,
ownerCommand,
TimeSpan.FromSeconds(30)).InstanceOwner;
instanceHandle.Free();
return instanceStore;
}
public virtual void SetDefaultWorkflowInstanceOwner(XName workflowHostTypeName, IEnumerable<WorkflowIdentity> workflowIdentities)
{
if (Store.DefaultInstanceOwner == null || (_ownerInstanceHandle == null || _ownerInstanceHandle.IsValid == false))
{
lock (_syncLock)
{
if (Store.DefaultInstanceOwner == null ||
(_ownerInstanceHandle == null || _ownerInstanceHandle.IsValid == false))
{
_workflowHostTypeName = workflowHostTypeName;
_workflowIdentities = workflowIdentities;
TryRenewInstanceHandle(ref _ownerInstanceHandle);
InstancePersistenceCommand createOwnerCmd = null;
#if NET4
createOwnerCmd = new CreateWorkflowOwnerCommand();
((CreateWorkflowOwnerCommand)createOwnerCmd).InstanceOwnerMetadata.Add(WorkflowNamespaces.WorkflowHostTypePropertyName, new InstanceValue(workflowHostTypeName));
#else
if (workflowIdentities == null)
{
createOwnerCmd = new CreateWorkflowOwnerCommand();
((CreateWorkflowOwnerCommand) createOwnerCmd).InstanceOwnerMetadata.Add(WorkflowNamespaces.WorkflowHostTypePropertyName, new InstanceValue(workflowHostTypeName));
}
else
{
// support workflow versioning
createOwnerCmd = new CreateWorkflowOwnerWithIdentityCommand();
((CreateWorkflowOwnerWithIdentityCommand)createOwnerCmd).InstanceOwnerMetadata.Add(WorkflowNamespaces.WorkflowHostTypePropertyName, new InstanceValue(workflowHostTypeName));
((CreateWorkflowOwnerWithIdentityCommand)createOwnerCmd).InstanceOwnerMetadata.Add(WorkflowNamespaces.DefinitionIdentityFilterName, new InstanceValue(WorkflowIdentityFilter.Any));
((CreateWorkflowOwnerWithIdentityCommand)createOwnerCmd).InstanceOwnerMetadata.Add(WorkflowNamespaces.DefinitionIdentitiesName, new InstanceValue(workflowIdentities.ToList()));
}
#endif
Store.DefaultInstanceOwner = ExecuteCommand(createOwnerCmd, DefaultTimeout).InstanceOwner;
}
}
}
}
InstancePersistenceCommand GetCreateOwnerCommand()
{
InstancePersistenceCommand command;
IDictionary<XName, InstanceValue> commandMetadata;
if (this.instanceOwnerMetadata.ContainsKey(Workflow45Namespace.DefinitionIdentities))
{
CreateWorkflowOwnerWithIdentityCommand withIdentity = new CreateWorkflowOwnerWithIdentityCommand();
command = withIdentity;
commandMetadata = withIdentity.InstanceOwnerMetadata;
}
else
{
CreateWorkflowOwnerCommand withoutIdentity = new CreateWorkflowOwnerCommand();
command = withoutIdentity;
commandMetadata = withoutIdentity.InstanceOwnerMetadata;
}
foreach (KeyValuePair<XName, InstanceValue> metadata in this.instanceOwnerMetadata)
{
commandMetadata.Add(metadata);
}
return command;
}
private bool CreateWorkflowOwner(InstancePersistenceContext context, CreateWorkflowOwnerCommand command)
{
Guid instanceOwnerId = Guid.NewGuid();
context.BindInstanceOwner(instanceOwnerId, instanceOwnerId);
context.BindEvent(HasRunnableWorkflowEvent.Value);
return true;
}
public void Open()
{
this.instanceStore = new SqlWorkflowInstanceStore(connectionString);
CreateWorkflowOwnerCommand createWorkflowOwnerCommand = new CreateWorkflowOwnerCommand();
InstanceHandle handle = this.instanceStore.CreateInstanceHandle();
try
{
this.instanceStore.BeginExecute(handle, createWorkflowOwnerCommand, TimeSpan.FromSeconds(30), OnInstanceStoreEndExecute, null);
}
catch (InstancePersistenceException persistenceException)
{
WriteException(persistenceException, "An error has occured setting up the InstanceStore");
}
}
protected override void GenerateSqlCommand(SqlCommand sqlCommand)
{
InstanceValue value2;
base.GenerateSqlCommand(sqlCommand);
if (base.StoreLock.IsValid)
{
throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(System.Activities.DurableInstancing.SR.MultipleLockOwnersNotSupported));
}
CreateWorkflowOwnerCommand instancePersistenceCommand = base.InstancePersistenceCommand as CreateWorkflowOwnerCommand;
SqlParameterCollection parameters = sqlCommand.Parameters;
double totalSeconds = base.Store.BufferedHostLockRenewalPeriod.TotalSeconds;
this.lockOwnerId = Guid.NewGuid();
this.ExtractWorkflowHostType();
if (instancePersistenceCommand.InstanceOwnerMetadata.TryGetValue(PersistenceMetadataNamespace.ActivationType, out value2))
{
if (!PersistenceMetadataNamespace.ActivationTypes.WAS.Equals(value2.Value))
{
throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(System.Activities.DurableInstancing.SR.NonWASActivationNotSupported));
}
this.fireActivatableInstancesEvent = true;
}
ArraySegment <byte>[] segmentArray = SerializationUtilities.SerializePropertyBag(instancePersistenceCommand.InstanceOwnerMetadata, base.Store.InstanceEncodingOption);
SqlParameter parameter = new SqlParameter {
ParameterName = "@lockTimeout",
SqlDbType = SqlDbType.Int,
Value = totalSeconds
};
parameters.Add(parameter);
SqlParameter parameter2 = new SqlParameter {
ParameterName = "@lockOwnerId",
SqlDbType = SqlDbType.UniqueIdentifier,
Value = this.lockOwnerId
};
parameters.Add(parameter2);
SqlParameter parameter3 = new SqlParameter {
ParameterName = "@workflowHostType",
SqlDbType = SqlDbType.UniqueIdentifier,
Value = (base.Store.WorkflowHostType != Guid.Empty) ? ((object)base.Store.WorkflowHostType) : ((object)DBNull.Value)
};
parameters.Add(parameter3);
SqlParameter parameter4 = new SqlParameter {
ParameterName = "@enqueueCommand",
SqlDbType = SqlDbType.Bit,
Value = base.Store.EnqueueRunCommands
};
parameters.Add(parameter4);
SqlParameter parameter5 = new SqlParameter {
ParameterName = "@deleteInstanceOnCompletion",
SqlDbType = SqlDbType.Bit,
Value = base.Store.InstanceCompletionAction == InstanceCompletionAction.DeleteAll
};
parameters.Add(parameter5);
SqlParameter parameter6 = new SqlParameter {
ParameterName = "@primitiveLockOwnerData",
SqlDbType = SqlDbType.VarBinary,
Size = segmentArray[0].Count,
Value = segmentArray[0].Array ?? DBNull.Value
};
parameters.Add(parameter6);
SqlParameter parameter7 = new SqlParameter {
ParameterName = "@complexLockOwnerData",
SqlDbType = SqlDbType.VarBinary,
Size = segmentArray[1].Count,
Value = segmentArray[1].Array ?? DBNull.Value
};
parameters.Add(parameter7);
SqlParameter parameter8 = new SqlParameter {
ParameterName = "@writeOnlyPrimitiveLockOwnerData",
SqlDbType = SqlDbType.VarBinary,
Size = segmentArray[2].Count,
Value = segmentArray[2].Array ?? DBNull.Value
};
parameters.Add(parameter8);
SqlParameter parameter9 = new SqlParameter {
ParameterName = "@writeOnlyComplexLockOwnerData",
SqlDbType = SqlDbType.VarBinary,
Size = segmentArray[3].Count,
Value = segmentArray[3].Array ?? DBNull.Value
};
parameters.Add(parameter9);
SqlParameter parameter10 = new SqlParameter {
ParameterName = "@encodingOption",
SqlDbType = SqlDbType.TinyInt,
Value = base.Store.InstanceEncodingOption
};
parameters.Add(parameter10);
SqlParameter parameter11 = new SqlParameter {
ParameterName = "@machineName",
SqlDbType = SqlDbType.NVarChar,
Value = SqlWorkflowInstanceStoreConstants.MachineName
};
parameters.Add(parameter11);
}
private Exception ProcessCreateWorkflowOwner(
InstancePersistenceContext context,
// ReSharper disable UnusedParameter.Local
CreateWorkflowOwnerCommand command)
// ReSharper restore UnusedParameter.Local
{
try
{
context.BindInstanceOwner(_ownerId, _lockToken);
return null;
}
catch(InstancePersistenceException exception)
{
Console.WriteLine(
// ReSharper disable LocalizableElement
"ProcessCreateWorkflowOwner exception: {0}",
// ReSharper restore LocalizableElement
exception.Message);
return exception;
}
}
private static SqlWorkflowInstanceStore CreateInstanceStore(WorkflowHandlerBase workflowInstance)
{
var store = new SqlWorkflowInstanceStore(ConnectionString);
var ownerHandle = store.CreateInstanceHandle();
var wfHostTypeName = GetWorkflowHostTypeName(workflowInstance);
var WorkflowHostTypePropertyName = GetWorkflowHostTypePropertyName();
var ownerCommand =
new CreateWorkflowOwnerCommand() { InstanceOwnerMetadata = { { WorkflowHostTypePropertyName, new InstanceValue(wfHostTypeName) } } };
store.DefaultInstanceOwner = store.Execute(ownerHandle, ownerCommand, TimeSpan.FromSeconds(30)).InstanceOwner;
return store;
}
