AndreaCol's Blog

Velocity Session delivered!

AndreaCol — Mon, 01 Jun 2009 08:30:05 GMT

Last week I presented my first session titled “introducing Microsoft Velocity”.

It was a practical overview about this cache framework, in which I’ve demonstrated all Velocity features in CTP3, and talked about the futures also.

The complete High Availability demo, with a 3 server cache cluster (3 VM running Velocity on WIN2008 with 512MB ram), was successfully presented. During this demo I stopped one of the servers, then requested the same page from another one (miming a Network Load Balancer) and keep getting my session cart and catalog items too. Then I restarted the same server and it joined the cache cluster serving session and catalog data seamlessly. I’ve also simulated a backoffice, winform application, from which I added a new product to the “live” catalog and It was soon displayed… and added to the cart from the Web Application.

Here are few pictures of me while presenting.

My first speech about Microsoft Velocity

AndreaCol — Sun, 24 May 2009 07:43:41 GMT

This week, I’ll be presenting a session titled “Introduction to Microsoft Velocity” at Community Nights, in Milan.

This will be my first public speech and, sorry if I’m wrong, will be also the first speech about Microsoft Velocity in Italy.

My interest about Velocity started during Tech-Ed EMEA 2008 in Barcelona, where I attended a session about this new project, that was still in CTP2. Since then I started playing with it, building a virtualized cluster and a demo application to demonstrate High Availability. During my studies, I faced to compare existing MS cache frameworks like ASP.Net Cache and Enterprise Library Caching Application Block, so I’ve published a feature matrix to explain and better identify Velocity strengths and place it in the right “department” when you’ll go shopping for a cache framework. By the way, if Velocity fits your needs, it will be available as free download (AFAIK).

In this blog you can also find some articles and posts about interesting things I’ve found on my way studying and playing with Velocity. In the official forum also I try to give my little contribution to people that faced to common issue or asked just a question about a feature, I’ve also asked some questions and received the right support quickly, even the project is still in CTP, there’s an efficient team behind it (msdn forums also use Velocity!).

After the session at Community Nights, I’ll post something about it, and on June 6th, I’ll be recording my first podcast about Velocity for the Italian .net community DotDotNet.

Thanks to Andrea and Daniele for giving me this great opportunity.

Cross fingers for me!

Velocity CTP3 cache notifications

AndreaCol — Sun, 26 Apr 2009 16:28:36 GMT

One of the new features introduced with CTP3, is the ability to subscribe notifications.

There are 3 types of notification levels: Cache, Region and Item.
Before analyzing all steps needed to start receiving notifications, let’s see how official documentation describes this feature:

“Cache notifications only report data-related changes to regions and cache items in the cluster, they do not report events of the cluster itself.”

Here’s showed the six-steps procedure to start listening to notifications.

Step 1: Create a notification-enabled namedCache using Powershell:

new-cache <chacheName> –NotificationsEnabled

Step 2: Get a DataCacheFactory instance using specific constructor:

        1: DataCacheFactory factory;

       2:             factory = new DataCacheFactory(servers, 

       3:                                            true,

       4:                                            false, 

       5:                                            DataCacheLocalCacheSyncPolicy.NotificationBased, 

       6:                                            100,

       7:                                            int.Parse(txtPollInterval.Text));

Step 3: Select which type of operations to listen to:

       1: //Which operations to listen to?

       2: DataCacheOperation allCacheOperations = DataCacheOperation.AddItem |

       3:                                         DataCacheOperation.ReplaceItem |

       4:                                         DataCacheOperation.RemoveItem |

       5:                                         DataCacheOperation.CreateRegion |

       6:                                         DataCacheOperation.ClearRegion |

       7:                                         DataCacheOperation.RemoveRegion;

Step 4: Provide a notification callback using delegate:

       1: //provide a notification callback

       2: DataCacheNotificationCallback cb;

       3: cb = new DataCacheNotificationCallback(OnNotificationReceived);

Step 5: Subscribe notifications using cache.addCacheLevelNotification method:

       1: //add cache-level notification callback 

       2: cache.AddCacheLevelCallback(allCacheOperations, cb);

Step 6: Implement your notification handling logic:

       1: public void OnNotificationReceived(string CacheName,

       2:                                    string regionName,

       3:                                    string key, 

       4:                                    DataCacheItemVersion version,

       5:                                    DataCacheOperation cacheOperation,

       6:                                    DataCacheNotificationDescriptor nd)

       7: {

       8:     if (string.IsNullOrEmpty(regionName)) regionName = "Default";

       9:  

      10:     string message = string.Format(@"{0} {1} in Cache: ""{2}"" Region: ""{3}""", cacheOperation.ToString(), key, CacheName, regionName);

      11:     notificationDelegate del = new notificationDelegate(LogNotification);

      12:     lstNotifications.Invoke(del,message );

      13: }

That’s all you need to do, but there is a detail to be aware of: as reported on this Velocity Forum thread, if you start listening to cache notifications, you’ll receive all notification history since the cluster has started, not just notifications from the point-in-time you start to listen.

Depending on each specific scenario, this behavior might both generate useless traffic or give the chance to get all notification history, so in my opinion it will be more flexible to be able to choose whether or not receive all notification history or from a specific point in time such callback creation or notification subscription.

Velocity CTP3 is out

AndreaCol — Wed, 08 Apr 2009 20:03:40 GMT

…and it’s time to update your assemblies, change the namespace to Microsoft.Data.Caching, add “data” prefix almost before any type:

…and update your web.config (pay attention to differences into names now starting with DataCacheXXX), here’s a full configuration file that works with Velocity CTP3:

        1: <?xml version="1.0"?>

       2: <configuration>

       3:     <configSections>

       4:         <sectionGroup name="system.web.extensions" type="System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">

       5:             <sectionGroup name="scripting" type="System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">

       6:                 <section name="scriptResourceHandler" type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>

       7:                 <sectionGroup name="webServices" type="System.Web.Configuration.ScriptingWebServicesSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">

       8:                     <section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere"/>

       9:                     <section name="profileService" type="System.Web.Configuration.ScriptingProfileServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>

                    <section name="authenticationService" type="System.Web.Configuration.ScriptingAuthenticationServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>

                    <section name="roleService" type="System.Web.Configuration.ScriptingRoleServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>

                </sectionGroup>

            </sectionGroup>

        </sectionGroup>

        <!-- Velocity 1 of 3 START -->

        <section name="dataCacheClient" type="Microsoft.Data.Caching.DataCacheClientSection, CacheBaseLibrary" allowLocation="true" allowDefinition="Everywhere"/>

    <section name="fabric" type="System.Data.Fabric.Common.ConfigFile, FabricCommon" allowLocation="true" allowDefinition="Everywhere"/>

        <!-- Velocity 1 of 3 END -->

    </configSections>

    <!-- Velocity 2 of 3 START-->

  <dataCacheClient deployment="routing">

        <localCache isEnabled="true" sync="TTLBased" ttlValue="300"/>

        <hosts>

            <!--List of services -->

            <host name="localhost" cachePort="22233" cacheHostName="DistributedCacheService"/>

        </hosts>

    </dataCacheClient>

    <fabric>

        <section name="logging" path="">

            <collection name="sinks" collectionType="list">

                <!--LOG SINK CONFIGURATION-->

                <!--defaultLevel Values:  -->

                <!--  -1 = no tracing -->

                <!--   0 = Errors only -->

                <!--   1 = Warnings and Errors only -->

                <!--   2 = Information, Warnings, Errors -->

                <!--   3 = Verbose (all event information)-->

                <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon" sinkName="System.Data.Fabric.Common.ConsoleSink,FabricCommon" sinkParam="" defaultLevel="-1"/>

                <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon" sinkName="System.Data.Fabric.Common.FileEventSink,FabricCommon" sinkParam="Dcache/dd-hh-mm" defaultLevel="-1"/>

        <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon" sinkName="Microsoft.Data.Caching.ETWSink, CacheBaseLibrary" sinkParam="" defaultLevel="-1"/>

      </collection>

        </section>

    </fabric>

    <!-- Velocity 2 of 3 END-->

    <appSettings/>

    <connectionStrings/>

    <system.web>

        <!--

    <sessionState mode ="InProc" cookieless="UseUri">

    Velocity 3 of 3 START

    <sessionState mode="Custom" customProvider="SessionStoreProvider" cookieless="UseUri">

            <providers>

                <add name="SessionStoreProvider" type="System.Data.Caching.SessionStoreProvider, ClientLibrary" cacheName="ASPNETSessionCache"/>

            </providers>

        </sessionState>

    Velocity 3 of 3 END

    -->

        <sessionState mode="Custom" customProvider="SessionStoreProvider" cookieless="UseUri">

            <providers>

                <add name="SessionStoreProvider" type="Microsoft.Data.Caching.DataCacheSessionStoreProvider, ClientLibrary" cacheName="ASPNETSessionCache"/>

            </providers>

        </sessionState>

        <compilation debug="false">

            <assemblies>

                <add assembly="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>

                <add assembly="System.Data.DataSetExtensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>

                <add assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

                <add assembly="System.Xml.Linq, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>

                <add assembly="System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>

                <add assembly="System.Web.Extensions.Design, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

                <add assembly="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/></assemblies>

        </compilation>

        <authentication mode="None"/>

        <!--

            The <customErrors> section enables configuration 

            of what to do if/when an unhandled error occurs 

            during the execution of a request. Specifically, 

            it enables developers to configure html error pages 

            to be displayed in place of a error stack trace.



        <customErrors mode="RemoteOnly" defaultRedirect="GenericErrorPage.htm">

            <error statusCode="403" redirect="NoAccess.htm" />

            <error statusCode="404" redirect="FileNotFound.htm" />

        </customErrors>

        -->

        <pages theme="DefaultTheme">

            <controls>

                <add tagPrefix="asp" namespace="System.Web.UI" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

                <add tagPrefix="asp" namespace="System.Web.UI.WebControls" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

            </controls>

        </pages>

        <httpHandlers>

            <remove verb="*" path="*.asmx"/>

            <add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

            <add verb="*" path="*_AppService.axd" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

            <add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" validate="false"/>

        </httpHandlers>

        <httpModules>

            <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

        </httpModules>

    </system.web>

    <system.codedom>

        <compilers>

            <compiler language="c#;cs;csharp" extension=".cs" warningLevel="4" type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

                <providerOption name="CompilerVersion" value="v3.5"/>

                <providerOption name="WarnAsError" value="false"/>

            </compiler>

        </compilers>

    </system.codedom>

    <!-- 

        The system.webServer section is required for running ASP.NET AJAX under Internet

        Information Services 7.0.  It is not necessary for previous version of IIS.

    -->

    <system.webServer>

        <validation validateIntegratedModeConfiguration="false"/>

        <modules>

            <remove name="ScriptModule"/>

            <add name="ScriptModule" preCondition="managedHandler" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

        </modules>

        <handlers>

            <remove name="WebServiceHandlerFactory-Integrated"/>

            <remove name="ScriptHandlerFactory"/>

            <remove name="ScriptHandlerFactoryAppServices"/>

            <remove name="ScriptResource"/>

            <add name="ScriptHandlerFactory" verb="*" path="*.asmx" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

            <add name="ScriptHandlerFactoryAppServices" verb="*" path="*_AppService.axd" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

            <add name="ScriptResource" preCondition="integratedMode" verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

        </handlers>

    </system.webServer>

    <runtime>

        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

            <dependentAssembly>

                <assemblyIdentity name="System.Web.Extensions" publicKeyToken="31bf3856ad364e35"/>

                <bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="3.5.0.0"/>

            </dependentAssembly>

            <dependentAssembly>

                <assemblyIdentity name="System.Web.Extensions.Design" publicKeyToken="31bf3856ad364e35"/>

                <bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="3.5.0.0"/>

            </dependentAssembly>

        </assemblyBinding>

    </runtime>

</configuration>

Now, after a first test, I’m updating all my cache hosts that are part of my Virtual Farm.

NHProfiler for my tool belt

AndreaCol — Sun, 15 Mar 2009 15:11:30 GMT

In these days, I’m working on a personal project that uses NHibernate to persist its entities. During development, it often happens to use SQL Server profiler, to check for roundtrips and database load because of NH transparent persistence and easy-to use api. SQL Profiler don’t offer a great UI for reading sql instructions and obviously is not aware of entities and sessions used by NH.

So I tried this tool, called NHProfiler, to have some benchmark data and interactive suggested practices to avoid common pitfalls using NHibernate.

First download NHProfiler from here, and add a reference in your project to this assembly: HibernatingRinos.NHibernate.Profiler.Appender.dll.

Now in the application startup (Application_Start in web applications, Program.Main in windows applications or the App constructor for WPF applications), initialize the profile as shown here:

Finally enable NHibernate statistics in your config file

<property name ="generate_statistics">True</property>

Now you’re ready to start profiling your application starting NHProfiler, and easily look to what’s happening behind the scenes: sql statements called, parameter’s value, sessions and benchmark data and finally alerts related to common pitfalls and suggestions (redirects to an online help page) on how to avoid them.

A great and easy to use tool, and I think is a must for who use NHibernate because:

it’s easy to set up and nonintrusive
clear statement, parameters and returned data inspection
Session factory statistics
Row count, duration and alerts for each statement
analysis: Unique queries, View by method and overall usage
cool user interface

but:

alerts are explained with online pages

Blog running on Windows 2008 and IIS7

AndreaCol — Mon, 16 Feb 2009 06:42:47 GMT

Wow, finally I did it, I’ve migrated all my sites, including this blog, on windows 2008 server and IIS7. It was a matter of submitting a migration form, chatting with technical staff, paying a 20$ fee, but it wasn’t a smooth procedure though, I mean that there were some issues with it, not much technical ones but almost regarding my ticket management… anyway so far so good, my development and “production” environments are now upgraded to latest server o.s. and IIS7.

70-564 beta PASSED!

AndreaCol — Sat, 24 Jan 2009 09:17:04 GMT

This morning I received the confirmation email: I’ve passed the beta exam: 70-564 Designing and Developing ASP.NET Applications Using the Microsoft® .NET Framework 3.5

The real exam number was 71-564 because was a beta exam.

Here’s the new logo:

I did this exam on November 28 2008, it took about two months to get the results, without any score, I wonder if it is possible to get the final score…

Book review: Pro Silverlight 2.0 in C# 2008

AndreaCol — Fri, 16 Jan 2009 19:03:29 GMT

My latest book review on Pro Silverlight 2.0 in C# 2008, a book I’ve read in December, is available here on AspAlliance site.

The return in northern Italy

AndreaCol — Sat, 10 Jan 2009 19:09:12 GMT

Here we are back in northern Italy, after a six days holiday in the south east where my and my wife's family live.

If the first plane was almost empty (28 people), the second one (the returning one) was full and the trip wasn't funny: the flight from Brindisi was delayed 4 hours due to bad weather conditions on Malpensa airport.

But the worst part of the trip was driving from Malpensa airport back to home. It was snowing and roads weren't safe, it was dangerous to drive to home. I tried to slow down without blocking, drive with an higher gear to avoid slips but summer-tires and the lack of snow chains made me harder to maintain full control of car. Fortunately we arrived safe at home, but was impossible to park inside, picture on the left show how I found my car the morning after.

Time to buy snow-chains and store it into my car, also a shovel to clean the garage front is needed... in case of snow.

Microsoft Project Code Named “Velocity”: a practical overview

AndreaCol — Wed, 31 Dec 2008 18:30:03 GMT

What Velocity is

Velocity is a Microsoft project, actually in CTP2, its goal is to provide a distributed, performing and highly available cache to our applications. Velocity could be integrated in Web and Desktop applications as well, thanks to a simple api is possible to perform basic operations like putting and getting managed objects from cache, but also more complex operations like locking and searching by several criteria.
One of the features that make Velocity an interesting project is High Availability. This is obtained creating and using a cache cluster, made of multiple servers that together run distributed cache service, transparently managing in-memory storage of our managed objects, their consistency, search and optionally the confinement in specific regions and servers finally, in case of sudden server failure, the redundancy by storing copies of our cached objects on secondary servers.

To better understand Velocity and compare it against existing cache frameworks, I've built this feature matrix [1].

Setting up cache cluster

The first step to start using Velocity is to create a Cache Cluster: a group of one or more servers on which the service responsible to provide distributed cache will run. To demonstrate Velocity’s key features we’ll use 3 servers: one for storing cache configuration settings and two as cache servers, on which Velocity service will run after being installed.

Fig.1 Cache Cluster

When installing Velocity on a cache server, a cluster configuration storage location must be specified, configuration includes a list of servers that are part of the cluster, TCP ports used for communications between cache services running on every server and other specific settings related to named caches created later. Three storage types are available for storing Velocity settings: XML-based file, SQL Compact edition (.sdf) and SQL Server which is the only cluster-aware, fault tolerant one.

For this demo, I've opted for the third choice, because is a nearly real-world scenario and it is easier to inspect tables that Velocity setup has created behind the scenes.

Fig.2 Cache host setup

Cluster configuration and administration is provided by Powershell console commands, well described and enlisted on MSDN documentation[2].

To start the cluster, launch Powershell (with Administrative privileges) from a cache server and type:

start-cachecluster

Fig.3 Starting the cluster from Powershell console

Though is now possible to use default cache, we proceed to create a named cache typing:

new-cache -CacheName CatalogCache -Secondaries 1 -TTL 15

After executing this command, a cache named “CatalogCache” will be created, leveraging 2 servers (primary and secondary), after an object is stored in cache, a second copy will be stored on secondary server and kept consistent with the original one, finally cache duration is configured to 15 minutes. To obtain some statistics about cache we just created, type:

get-cachestatistics

Fig.4 get-cache and get-cachestatistics console output

Demo overview

The application used in the demo emulates an online electronics shop, where customers can browse a simplified product catalog and add products to their shopping cart. Now let’s suppose that loading catalog is such as long-running operation, querying several heterogeneous data sources and for these reasons a cache strategy is suitable between Data Access Layer and data sources. The catalog became a good candidate to be stored in cache, increasing application responsiveness and avoiding database roundtrips.

Note: Although the techniques used in the demo are similar to many real world scenarios, these are not the recommended way to manage an online catalog: It’s only a demo.

Setting up development environment and start using Velocity

To start using Velocity in our applications, just add references to following assemblies, picking them from Velocity’s installation folder from one of the cache servers:

Then add the Velocity namespace:

Using System.Data.Caching;

Here’s a code listing used to access the named cache created previously, you can see that an array of ServerEndPoint is first created, representing our cluster, then a CacheFactory is used to create a CacheClient which can be used to put and get objects in cache back and forth.

   1: //Declaring cluster's servers

2:

   3: ServerEndPoint[] servers = new ServerEndPoint[2];

4:

   5: servers[0] = new ServerEndPoint("SERVER1", 22233, "distributedCacheService");

6:

   7: servers[1] = new ServerEndPoint("SERVER2", 22233, "distributedCacheService");

8:

   9: //Creating cacheFactory

10:

  11: CacheFactory factory = new CacheFactory(servers, true, false);

12:

  13: //Accessing named cache

14:

  15: Cache catalogCache = factory.GetCache("CatalogCache");

16:

  17: //Putting catalog into Velocity cache

18:

  19: catalogCache.Put("Catalog1", CatalogManager.GetCatalog("Catalog1"));

20:

After putting the object in cache, is now possible to retrieve it later as showed here:

//Getting catalog from Velocity cache 

Catalog myCatalog = (Catalog)catalogCache.Get("Catalog1");

In the demo application, the catalog is first loaded from database, then it is stored in cache, at this point the same catalog can be accessed from any application running on any web server in the farm. This is a different behavior from ASP.NET cache, in which every web server can access only its own cache. You can look at the address bars in fig.5, and see that the catalog is browsed using 2 different servers, but catalog is the same loaded at the time displayed in statistics box. This could happen because objects are not stored in the same AppDomain of web application (as would happen using ASP.NET cache) but they are stored in Velocity cache, which offer a unified view of memory of all servers in the cluster.

Fig.5 same page requested from 2 different web servers, accessing same Velocity cache (click to enlarge)

(SERVER1)

(SERVER2)

ASP.NET Integration

At this point as you may guess, let’s see how we could integrate Velocity in our ASP.NET applications, obtaining a valid option for centralized Session management in addition to existing StateServer and SQLServer modes. With StateServer, thanks to a service running on a state server, we'll get a centralized session management, and the ability to distribute and balance web requests on several web servers in the farm, maintaining acceptable performances. In this scenario, all web servers rely on a single state server on which all sessions are maintained. If High Availability is a requirement, this would not be satisfied as a sudden failure of StateServer would cause the loss of all sessions.

An alternative solution could be storing sessions on SQL Server database, but with it we also should accept performance loss when accessing session data, at least 25% less.

Velocity aims to mitigate these weakness exposed by both StateServer and SQLServer modes, offering a Session Provider that emulates a distributed and redundant StateServer, using a cluster of servers running cache service.

To appreciate this feature, we must instruct our application to use Velocity’s Session Provider, modifying web.config as explained in these three steps:

1) Declare dCacheClient and Fabric config sections:

<section name="dcacheClient"

type="System.Data.Caching.DCacheClientSection, CacheBaseLibrary"

allowLocation="true"

allowDefinition="Everywhere"/>

<section name="fabric"

type="System.Data.Fabric.Common.ConfigFile, FabricCommon"

allowLocation="true"

allowDefinition="Everywhere"/>

2) Configure dCacheClient section, adding available servers in the cluster and the behavior of cacheClient. Also configure the fabric section, declaring logging mechanisms that cacheClient will use:

<dcacheClient deployment="simple">

    <localCache isEnabled="true" sync="TTLBased" ttlValue="300"/>

    <hosts>

        <!--List of cache servers (cache cluster) -->

        <host name="SERVER1"

              cachePort="22233"

              cacheHostName="DistributedCacheService"/>

        <host name="SERVER2"

              cachePort="22233"

              cacheHostName="DistributedCacheService"/>

    </hosts>

</dcacheClient>

<fabric>

    <section name="logging" path="">

        <collection name="sinks" collectionType="list">

            <!--LOG SINK CONFIGURATION-->

            <!--defaultLevel Values: -->

            <!-- -1 = no tracing -->

            <!-- 0 = Errors only -->

            <!-- 1 = Warnings and Errors only -->

            <!-- 2 = Information, Warnings, Errors -->

            <!-- 3 = Verbose (all event information)-->

            <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"

                        sinkName="System.Data.Fabric.Common.ConsoleSink,FabricCommon"

                        sinkParam=""

                        defaultLevel="-1"/>

            <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"

                        sinkName="System.Data.Fabric.Common.FileEventSink,FabricCommon"

                        sinkParam="Dcache/dd-hh-mm"

                        defaultLevel="-1"/>

            <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"

                        sinkName="System.Data.Caching.ETWSink, CacheBaseLibrary"

                        sinkParam=""

                        defaultLevel="-1"/>

        </collection>

    </section>

</fabric>

3) Change sessionState Mode parameter, setting “Custom” and declare the Velocity Provider that will be used as Session Provider:

<sessionState mode="Custom"

              customProvider="SessionStoreProvider"

              cookieless="UseUri">

    <providers>

        <add name="SessionStoreProvider"

             type="System.Data.Caching.SessionStoreProvider, ClientLibrary"/>

    </providers>

</sessionState>

To demonstrate the use of Velocity Session Provider, I’ve also set cookieless parameter to “UseUri” for convenience, to be able to access the same session data simply copying part of the address switching from one server to another.

Following images show, using two different browsers, how is possible to access the same session data from two different servers, getting the same shopping cart content. This means that we’re accessing a centralized session data, but we’re also relying on a cluster of cache servers at the same time, on which Velocity is running, providing a performing, high available and easy to use cache.

Fig.6 same page and session, requested from 2 different web servers. Notice the shopping cart on the right side (click to enlarge).

(SERVER1)

(SERVER2)

Conclusions

This overview demonstrates only few Velocity's features, in particular the ability to use Velocity as distributed and redundant cache, that could be accessed either web or desktop applications as well, using the same api. All other features, which emerge from this feature matrix, deserve an entire article or more.
Once overcome the initial setup and configuration phase, we can benefit of a performing, reliable and easy to use cache. Finally with just few changes to web.config file, it is possible to integrate Velocity in existing web applications, leveraging its Session Provider and implicitly obtaining all its benefits.

References

[1] Cache frameworks feature matrix
[2] Velocity powershell commands
[3] Velocity Documentation on MSDN
[4] Velocity log sink settings and Velocity-aware web.config