SqlWorkflowInstanceStore WaitForEvents返回HasRunnableWorkflowEvent但LoadRunnableInstance失败

Question

亲爱

请帮我恢复延迟(和持久)的工作流程.

我正在尝试检查自托管工作流程存储是否存在任何延迟且可以恢复的实例.出于测试目的,我创建了延迟的虚拟活动,并且在延迟时间内持续存在.

一般恢复过程看起来像:

get WF definition
configure sql instance store 
call WaitForEvents
is there event with HasRunnableWorkflowEvent.Value name and if it is
create WorkflowApplication object and execute LoadRunnableInstance  method

如果商店被称为商店关闭created|initialized,它的工作正常WaitForEvents.在这种情况下,存储从持久数据库中读取所有可用的工作流,如果没有workflows可用的恢复,则抛出超时异常.

如果创建了存储并且仅为WaitForEvents(同样的事情发生BeginWaitForEvents)启动循环,则会出现问题.在这种情况下,它会workflows从DB(使用适当的ID)读取所有可用的内容,但之后timeout exception它将再读取一个实例(我确切地知道有多少实例workflows可以恢复,因为使用了单独的测试database).但没有阅读和throws InstanceNotReadyException.在catch我正在检查workflowApplication.Id,但它之前没有保存我的测试.

我试图在新的(空)持久数据库上运行,结果是一样的:(

此代码失败:

using (var storeWrapper = new StoreWrapper(wf, connStr))
    for (int q = 0; q < 5; q++)
    {
        var id = Resume(storeWrapper); // InstanceNotReadyException here when all activities is resumed

但是这个按预期工作:

for (int q = 0; q < 5; q++)
    using (var storeWrapper = new StoreWrapper(wf, connStr))
    {
        var id = Resume(storeWrapper); // timeout exception here or beginWaitForEvents continues to wait

在这种情况下,什么是最佳解决方案？添加空catch的InstanceNotReadyException,而忽略了吗？

这是我的测试

const int delayTime = 15;
string connStr = "Server=db;Database=AppFabricDb_Test;Integrated Security=True;";

[TestMethod]
public void PersistOneOnIdleAndResume()
{
    var wf = GetDelayActivity();

    using (var storeWrapper = new StoreWrapper(wf, connStr))
    {
        var id = CreateAndRun(storeWrapper);
        Trace.WriteLine(string.Format("done {0}", id));
    }

    using (var storeWrapper = new StoreWrapper(wf, connStr))
    for (int q = 0; q < 5; q++)
    {
        var id = Resume(storeWrapper);
        Trace.WriteLine(string.Format("resumed {0}", id));
    }

}

Activity GetDelayActivity(string addName = "")
{
    var name = new Variable<string>(string.Format("incr{0}", addName));
    Activity wf = new Sequence
    {
        DisplayName = "testDelayActivity",
        Variables = { name, new Variable<string>("CustomDataContext") },
        Activities =
            {
            new WriteLine
                {
                    Text = string.Format("before delay {0}", delayTime)
                },
                new Delay
                {
                    Duration = new InArgument<TimeSpan>(new TimeSpan(0, 0, delayTime))
                },
                new WriteLine
                {
                    Text = "after delay"
                }
            }
    };
    return wf;
}

Guid CreateAndRun(StoreWrapper sw)
{
    var idleEvent = new AutoResetEvent(false);
    var wfApp = sw.GetApplication();

    wfApp.Idle = e => idleEvent.Set();
    wfApp.Aborted = e => idleEvent.Set();
    wfApp.Completed = e => idleEvent.Set();

    wfApp.Run();

    idleEvent.WaitOne(40 * 1000);
    var res = wfApp.Id;
    wfApp.Unload();
    return res;
}

Guid Resume(StoreWrapper sw)
{
    var res = Guid.Empty;

    var events = sw.GetStore().WaitForEvents(sw.Handle, new TimeSpan(0, 0, delayTime));

    if (events.Any(e => e.Equals(HasRunnableWorkflowEvent.Value)))
    {
        var idleEvent = new AutoResetEvent(false);

        var obj = sw.GetApplication();
        try
        {
            obj.LoadRunnableInstance(); //instancenotready here if the same store has read all instances from DB and no delayed left

            obj.Idle = e => idleEvent.Set();
            obj.Completed = e => idleEvent.Set();

            obj.Run();

            idleEvent.WaitOne(40 * 1000);

            res = obj.Id;

            obj.Unload();
        }
        catch (InstanceNotReadyException)
        {
            Trace.TraceError("failed to resume {0} {1} {2}", obj.Id
                , obj.DefinitionIdentity == null ? null : obj.DefinitionIdentity.Name
                , obj.DefinitionIdentity == null ? null : obj.DefinitionIdentity.Version);
            foreach (var e in events)
            {
                Trace.TraceWarning("event {0}", e.Name);
            }
            throw;
        }
    }
    return res;
}

这是我用于测试的商店包装器定义:

public class StoreWrapper : IDisposable
{
    Activity WfDefinition { get; set; }

    public static readonly XName WorkflowHostTypePropertyName = XNamespace.Get("urn:schemas-microsoft-com:System.Activities/4.0/properties").GetName("WorkflowHostType");
    public StoreWrapper(Activity wfDefinition, string connectionStr)
    {
        _store = new SqlWorkflowInstanceStore(connectionStr);

        HostTypeName = XName.Get(wfDefinition.DisplayName, "ttt.workflow");

        WfDefinition = wfDefinition;

    }

    SqlWorkflowInstanceStore _store;

    public SqlWorkflowInstanceStore GetStore()
    {
        if (Handle == null)
        {

            InitStore(_store, WfDefinition);
            Handle = _store.CreateInstanceHandle();

            var view = _store.Execute(Handle, new CreateWorkflowOwnerCommand
            {
                InstanceOwnerMetadata = { { WorkflowHostTypePropertyName, new InstanceValue(HostTypeName) } }
            }, TimeSpan.FromSeconds(30));

            _store.DefaultInstanceOwner = view.InstanceOwner;

            //Trace.WriteLine(string.Format("{0} owns {1}", view.InstanceOwner.InstanceOwnerId, HostTypeName));
        }

        return _store;
    }

    protected virtual void InitStore(SqlWorkflowInstanceStore store, Activity wfDefinition)
    {
    }

    public InstanceHandle Handle { get; protected set; }

    XName HostTypeName { get; set; }

    public void Dispose()
    {
        if (Handle != null)
        {
            var deleteOwner = new DeleteWorkflowOwnerCommand();

            //Trace.WriteLine(string.Format("{0} frees {1}", Store.DefaultInstanceOwner.InstanceOwnerId, HostTypeName));

            _store.Execute(Handle, deleteOwner, TimeSpan.FromSeconds(30));
            Handle.Free();
            Handle = null;

            _store = null;
        }
    }

    public WorkflowApplication GetApplication()
    {
        var wfApp = new WorkflowApplication(WfDefinition);
        wfApp.InstanceStore = GetStore();
        wfApp.PersistableIdle = e => PersistableIdleAction.Persist;

        Dictionary<XName, object> wfScope = new Dictionary<XName, object> { { WorkflowHostTypePropertyName, HostTypeName } };
        wfApp.AddInitialInstanceValues(wfScope);

        return wfApp;
    }
}

Answer 1

我不是工作流基础专家，所以我的答案基于微软的官方示例。第一个是WF4 主机恢复延迟工作流 (CSWF4LongRunningHost)，第二个是Microsoft.Samples.AbsoluteDelay。在这两个示例中，您会发现与您的代码类似的代码，即：

try 
{
    wfApp.LoadRunnableInstance();
    ...
} 
catch (InstanceNotReadyException) 
{
    //Some logging
}

考虑到这一点，答案是你是对的，空捕获InstanceNotReadyException是一个很好的解决方案。