Improving The Page Flow Application Block: Removing Database Dependencies

Resources for geekSpeak - Web Client Software Factory with Paulo Morgado

Noticias externas — Mon, 04 Feb 2008 21:56:27 GMT

Here is a great set of resources from our guest Paulo Morgado. Catch the recording here . Contextual

Resources for geekSpeak - Web Client Software Factory with Paulo Morgado

geekSpeak — Mon, 04 Feb 2008 21:20:23 GMT

Here is a great set of resources from our guest Paulo Morgado. Catch the recording here . Contextual

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Wed, 23 Jan 2008 13:43:57 GMT

Are you sure it's the compression that is taking the 100 milliseconds? I'm asking because I haven't measured it yet.

The WorkflowPersistenceService.GetDefaultSerializedForm does a lot more than just compression the workflow.

You can activate the workflow traces (runtime, tracking and host) but setting (in your configuration file) the value of the following SourceSwitches:

System.Workflow.Runtime
System.Workflow.Runtime.Tracking
System.Workflow.Runtime.Hosting

for the TraceSources with the same name.

Additionally, you can enable the following BooleanSwitches:

System.Workflow LogToFile - To output traces to the WorkflowTrace.log file.
System.Workflow LogToTraceListeners - To output traces to the registered trace listeners.

re: Improving The Page Flow Application Block: Removing Database Dependencies

TJ — Wed, 23 Jan 2008 12:24:35 GMT

But even if I read and write my data to UserData only once per request I can still take away almost 100 milliseconds by commenting out the compression.

I'm looking forward to the pageflow bundle that doesn't require a workflow (www.codeplex.com/.../View.aspx). You don't happen to know anything about its schedule?

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Sat, 19 Jan 2008 20:00:03 GMT

When Joern says that "GetDefaultSerializedForm() does the compression", it's not because he choosed to. It's becaus that's how wrokflow serialization works (look it up with Reflector).

I think your real problem is too much access to UserData in the same request.

re: Improving The Page Flow Application Block: Removing Database Dependencies

TJ — Sat, 19 Jan 2008 11:51:00 GMT

But is there a way to disable compression totally with the current implementation?

I tried by commenting out these lines in the PageFlowStorageSessionStateProvider (also a few other changes were needed)

byte[] data = WorkflowPersistenceService.GetDefaultSerializedForm(rootActivity);

return WorkflowPersistenceService.RestoreFromDefaultSerializedForm(data, outerActivity);

By doing that I got error messages complaining about PageFlow not beeing serializable and had to switch to InProc mode. Can I also somehow disable compression of the underlying workflow?

I implemented retrieving all UserData in OnInit and storing in PreRender of a common page base class. Seems to work ok, but I guess there could be a more elegant solution..

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Fri, 18 Jan 2008 22:40:36 GMT

Every time you access the UserData, the underlying workflow of the page flow is loaded, ran and unloaded. Decompression is part of the loading process and compression is part of the unloading process.

The PageFlow object is not serializable because it doesn't need to. On each request, the underlying workflow is loaded and wrapped by a new PageFlow instance.

As you figured out, with the present implementation of the WorkflowFoundationPageFlow, you should touch the UserData property as less as possible.

I totally agree with you that the underlying workflow should only be loaded and unloaded once per HTTP request. I hope to continue this series of articles about the Page Flow Application Block soon and I'll try to implement that.

re: Improving The Page Flow Application Block: Removing Database Dependencies

TJ — Fri, 18 Jan 2008 10:20:20 GMT

Thanks for sharing!

I noticed that the data compression as Joern suggests turned out to be a bit problematic in my case.

Seems like the compression/decompression occurs each time I access the data. When reading/writing same data multiple times within a single request (like with session you can do), the total time consumed in retrieving/saving the data builds up very high.

I tried to tackle this problem by commenting out the parts where the compression/decompression occurs and storing an Activity objects instead (this forced me to change session to InProc mode as PageFlow object is not Serializable).

But still it seems to take an awful long time to get the property Data a few times:

public MyObject[] Data
{
  get
  {
    if (!CurrentPageFlow.UserData.Contains("MyObject"))
      return null;
    return CurrentPageFlow.UserData["MyObject"] as MyObject[];
  }
  set { CurrentPageFlow.UserData["MyObject"] = value; }
}

Should I instead store all my objects inside a container and retrieve/store that object only once per request?

Also, session enables to do things like this:

MyObject data = Session["somekey"];
data.Property = otherdata; // new Property contents will be saved eventually
// With pageflow the data doesn't get stored I set it explicitly
MyObject data = MyPageFlow.UserData["somekey"];
data.Property = otherdata;
MyPageFlow.UserData["somekey"] = data; // This is required

What would be the best approach to make the data be stored at the end of the request execution like session does it?

http://dotnetkicks.com/aspnet/improving_the_page_flow_application_block_removing_database_dependenc

TrackBack — Tue, 15 Jan 2008 22:22:04 GMT

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Wed, 28 Nov 2007 00:30:42 GMT

Hi Mike,

Joem did a great job.

To make it work in the sample I just replaced:

with:

I'll post the modified sample as soon as I can.

re: Improving The Page Flow Application Block: Removing Database Dependencies

Mike — Tue, 27 Nov 2007 12:02:51 GMT

Hi Paulo, Joem,

Good work! Why didn't they include it out of the box?!

I tried Joem's example.

However changing the sql provider by itself (1 line in the web.config) is not enough.

Could you send me a working example by E-mail?

mi.van.engelenDELETEME@DELETEMEinterpolis.nl

Regards,

Mike

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Sat, 03 Nov 2007 12:12:09 GMT

Thanks a lot Joem.

This was my first choice of how to do it, but, due to the lack of time and, mostly, Workflow Foundation knowledge, I took the quick way out.

I'll add it to the article and code download as soon as possilbe (I'm heading for TechEd Developers Europe).

re: Improving The Page Flow Application Block: Removing Database Dependencies

Joern — Fri, 02 Nov 2007 20:53:48 GMT

Because I did not want to patch the Microsoft.Practices.PageFlow.WorkflowFoundation.WorkflowFoundationPageFlow.Suspend and PageFlow.WorkflowFoundation.WorkflowFoundationPageFlowFactory.GetPageFlow methods and I felt it would be a good idea to have both providers,

I implemented a memory persistence service. (Based on your correlation provider.)

It replaces the SQL persistence service and serializes the workflow state to the ASP.NET session. (In a form that should allow it to be persisted to any database.)

Just replace the SQL provider in the web.config file with this provider.

Also, if used in a production environment, it saves memory by persisting the workflow to a compressed format if the workflow is idle - which basically means after each page request. (In my tests the persisted workflow required about 7k in compressed format and 60k in uncompressed format.)

BTW, GetDefaultSerializedForm() does the compression.

Here is the code:

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Web;
using System.Workflow.ComponentModel;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;
namespace Joern.PageFlow.SimpleStorage.SessionState
{
   /// <summary>
   /// Implements the custom WorkflowPersistenceService, which persists workflow instances in the ASP.NET session.
   /// </summary>
   public class PageFlowStorageSessionStateProvider : WorkflowPersistenceService
   {
       private const string SessionStateStorageName = "PageFlowWorkflowStore";
       public PageFlowStorageSessionStateProvider()
       {
       }
       #region Serialization
       /// <summary>
       /// Performs the serialization of one activity. Invoked during dehydration.
       /// </summary>
       /// <param name="id"></param>
       /// <param name="rootActivity"></param>
       private void SerializeActivity(Guid id, Activity rootActivity)
       {
           byte[] data = WorkflowPersistenceService.GetDefaultSerializedForm(rootActivity);
           SessionStorage.WriteInstanceData(id, data);
       }
       /// <summary>
       /// Performs deserialization of persisted activity. Invoked during rehydration.
       /// </summary>
       /// <param name="id"></param>
       /// <param name="outerActivity"></param>
       /// <returns></returns>
       private Activity DeserializeActivity(Guid id, Activity outerActivity)
       {
           byte[] data = SessionStorage.LoadInstanceData(id);
           return WorkflowPersistenceService.RestoreFromDefaultSerializedForm(data, outerActivity);
       }
       /// <summary>
       /// Removes the serialization of an activity. Invoked when the workflow is completed or terminated.
       /// </summary>
       /// <param name="id"></param>
       private void DeleteActivity(Guid id)
       {
           SessionStorage.DeleteInstance(id);
       }
       #endregion
       #region Provider Members
       #region WorkflowProvider Interface Implementation
       protected override Activity LoadCompletedContextActivity(Guid scopeId, Activity outerActivity)
       {
           //Trace.WriteLine("Rehydration");
           object obj = DeserializeActivity(scopeId, outerActivity);
           return (Activity)obj;
       }
       protected override Activity LoadWorkflowInstanceState(Guid instanceId)
       {
           //Trace.WriteLine("Rehydration");
           object obj = DeserializeActivity(instanceId, null);
           return (Activity)obj;
       }
       protected override void SaveCompletedContextActivity(Activity activity)
       {
           Guid contextGuid = (Guid)activity.GetValue(Activity.ActivityContextGuidProperty);
           SerializeActivity(contextGuid, activity);
       }
       protected override void SaveWorkflowInstanceState(Activity rootActivity, bool unlock)
       {
           Guid contextGuid = (Guid)rootActivity.GetValue(Activity.ActivityContextGuidProperty);
           WorkflowStatus workflowStatus = WorkflowPersistenceService.GetWorkflowStatus(rootActivity);
           if ((workflowStatus != WorkflowStatus.Completed) && (workflowStatus != WorkflowStatus.Terminated))
           {
               SerializeActivity(contextGuid, rootActivity);
           }
           else
           {
               DeleteActivity(contextGuid);
           }
       }
       protected override bool UnloadOnIdle(Activity activity)
       {
           return true;
       }
       protected override void UnlockWorkflowInstanceState(Activity rootActivity)
       {
       }
       #endregion
       #endregion
       private Storage SessionStorage
       {
           get
           {
               Storage pageFlowStorage = HttpContext.Current.Session[SessionStateStorageName] as Storage;
               if (pageFlowStorage == null)
               {
                   HttpContext.Current.Session[SessionStateStorageName] = pageFlowStorage = new Storage();
               }
               return pageFlowStorage;
           }
       }
       [Serializable]
       private class Storage : ISerializable
       {
           private SortedList<Guid, StorageItem> items = new SortedList<Guid, StorageItem>();
           /// <summary>
           /// Initializes a new instance of the Storage class.
           /// </summary>
           public Storage()
           {
           }
           #region ISerializable Members
           /// <summary>
           /// Initializes a new instance of the <see cref="Storage"/> class.
           /// </summary>
           /// <param name="info">The info.</param>
           /// <param name="context">The context.</param>
           protected Storage(SerializationInfo info, StreamingContext context)
           {
               this.items = (SortedList<Guid, StorageItem>)info.GetValue("items", typeof(SortedList<Guid, StorageItem>));
           }
           /// <summary>
           /// Populates a <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> with the data needed to serialize the target object.
           /// </summary>
           /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> to populate with data.</param>
           /// <param name="context">The destination (see <see cref="T:System.Runtime.Serialization.StreamingContext"></see>) for this serialization.</param>
           /// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission. </exception>
           void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
           {
               info.AddValue("items", this.items);
           }
           #endregion
           internal void WriteInstanceData(Guid instanceId, byte[] data)
           {
               StorageItem item;
               if (!this.items.TryGetValue(instanceId, out item))
               {
                   item = new StorageItem();
                   this.items.Add(instanceId, item);
                   item.InstanceId = instanceId;
               }
               item.Data = data;
           }
           internal byte [] LoadInstanceData(Guid instanceId)
           {
               StorageItem item;
               if (this.items.TryGetValue(instanceId, out item))
                   return item.Data;
               return null;
           }
           internal void DeleteInstance(Guid instanceId)
           {
               if (this.items.ContainsKey(instanceId))
                   this.items.Remove(instanceId);
           }
           [Serializable]
           private class StorageItem
           {
               public Guid InstanceId;
               public byte [] Data;
           }
       }
   }

}

Feel free to share it with the community.

Joern

Bug Found On The Page Flow Without Database Improvement - Paulo Morgado

Bug Found On The Page Flow Without Database Improvement - Paulo Morgado — Thu, 01 Nov 2007 19:16:35 GMT

Pingback from Bug Found On The Page Flow Without Database Improvement - Paulo Morgado

re: Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Wed, 31 Oct 2007 01:03:27 GMT

Thanks Joern,

You're absolutely right about the code. I don't know what I was thinking of when I wrote that.

(By the way, I think it now works with any session state storage, but I haven't tested it.)

re: Improving The Page Flow Application Block: Removing Database Dependencies

Joern — Tue, 30 Oct 2007 20:03:54 GMT

Thanks for the code!!!

I believe I found a bug:

private Storage PageFlowStorage
   {
       get
       {
           if (this.pageFlowStorage == null)
           {
               this.pageFlowStorage = HttpContext.Current.Session[this.pageFlowStorageName] as Storage;
               if (this.pageFlowStorage == null)
               {
                   HttpContext.Current.Session[this.pageFlowStorageName] = this.pageFlowStorage = new Storage();
               }
           }
           return this.pageFlowStorage;
       }
   }

With this implementation the pageFlowStorage is cached by the PageFlowInstanceCorrelationAspNetSessionStateProvider class. I have not tested it but I believe that there is only one instance of the class per ASP.NET application. Therefore, with this implementation the storage really is tied to the class instance and not the Session object.

I would implement:

private Storage PageFlowStorage
   {
       get
       {
           Storage s = HttpContext.Current.Session[this.pageFlowStorageName] as Storage;
           if (s == null)
           {
                   HttpContext.Current.Session[this.pageFlowStorageName] = s = new Storage();
           }
           return s;
       }
   }

Your implementation works because the provider probably goes out of scope, when the Application unloads. But I guess that is not what you intended. (By the way, caching it on the provider level probably won't work neither if the Session is stored in a database.)

Improving The Page Flow Application Block: Removing Database Dependencies

Paulo Morgado — Thu, 25 Oct 2007 23:00:38 GMT

In this first article of the series I'll show how you can use the Page Flow Application Block of

Improving The Page Flow Application Block - Paulo Morgado

Improving The Page Flow Application Block - Paulo Morgado — Sun, 21 Oct 2007 18:39:55 GMT

Pingback from Improving The Page Flow Application Block - Paulo Morgado