In previous post I wrote how to invoke AppFabric management PowerShell commands from F# interactive. Now we successfully created named cache in AppFabric distributed cache and I want to use AppFabric cache API to store and retrieve data from this cache. You can structure data stored in named cache using cache regions (which roughly correspond to tables in relational database). Data could be stored in the region using string keys which work as in usual hashtable.

But first of all you need to find out how to refer to AppFabric API assemblies in F# project. MSDN documentation tells the following: “On 64-bit operating systems, the AppFabric directory will not be directly visible. To work around this problem, replace the System32 directory name with the name SysNative. This results in navigating to the C:\Windows\SysNative\AppFabric directory in this step”. So I added a reference to these assemblies in my F# script file:

F#, using GeSHi 1.0.8.8
#r @"C:\Windows\SysNative\AppFabric\Microsoft.ApplicationServer.Caching.Core.dll"
Parsed in 0.007 seconds at 11.99 KB/s

So far all looks OK, but when I selected this line and sent it to FSI window I’ve got this error message:

“error FS0084: Assembly reference 'C:\Windows\SysNative\AppFabric\Microsoft.ApplicationServer.Caching.Core.dll' was not found or is invalid”. I tried to search for this message but didn’t found any workaround. (It’s strange because this exact reference works perfectly when I added it to the project, but it still gives me an error in FSI window). To make it work in FSI I had to copy all needed AppFabric assemblies to the usual folder I created on my hard drive and refer to these copied assemblies from script file. It’s kind of ugly but it seems to work. So my references in script look like this:

F#, using GeSHi 1.0.8.8
#r @"C:\Projects\Velocity4\Microsoft.ApplicationServer.Caching.Core.dll"
#r @"C:\Projects\Velocity4\Microsoft.ApplicationServer.Caching.Client.dll"
#r @"C:\Projects\Velocity4\Microsoft.ApplicationServer.Caching.Management.dll"
#r @"C:\Projects\Velocity4\Microsoft.ApplicationServer.Caching.ManagementPS.dll"
#r @"C:\Projects\Velocity4\Microsoft.ApplicationServer.Caching.Configuration.dll"
 

Now I could use cache API.First of all we need to create DataCacheFactory object and DataCache client. (By the way MSDN has pretty good documentation on Windows Server AppFabric Caching Concepts and Architecture)

F#, using GeSHi 1.0.8.8
open System
open Microsoft.ApplicationServer.Caching
 
let createDataCacheFactory = 
    let config = DataCacheFactoryConfiguration()
    config.LocalCacheProperties <- DataCacheLocalCacheProperties() // use local cache in the cache client
    config.Servers <- [DataCacheServerEndpoint(Environment.MachineName, 22233)]
    new DataCacheFactory(config)
 
let createCacheClient cacheName = 
    let factory = createDataCacheFactory
    cacheName |> factory.GetCache
Parsed in 0.016 seconds at 29.76 KB/s

Now we can use DataCache object to manipulate data in our cache (I will not describe or implement complete cache API here but rather illustrate main concepts):

F#, using GeSHi 1.0.8.8
let putData (cache: DataCache) key value (region: string) =
    cache.Put(key, value, region)
 
let getData (cache: DataCache) key (region: string) =
    cache.Get(key, region)
 
let removeData (cache: DataCache) key (region: string) =
    cache.Remove(key, region)
 
let createRegion (cache: DataCache) regionName = 
    cache.CreateRegion regionName
 
let removeRegion (cache: DataCache) regionName =
    cache.RemoveRegion regionName
 
Parsed in 0.016 seconds at 27.77 KB/s

So we can now create some simple test data and test our F# API wrapper:

F#, using GeSHi 1.0.8.8
// Creating cache client for our named cache:
let cacheClient = createCacheClient "MyCache"
// Creating the region to store data
createRegion cacheClient "TestRegion"
// Creating simple test data
let testData = seq { 
    for i in 1 .. 10000 do
    yield (sprintf "key%d" i , sprintf "data%d" i) }
// Populate our cache region
testData |> Seq.iter (fun (fst, snd) -> putData cacheClient fst snd "TestRegion"|> ignore)
 
// Retrieve and print all data:
let getAllData = 
    for i in 1 .. 10000 do
    let key = sprintf "key%i" i
    let d = getData cacheClient key "TestRegion" 
    printfn "GotData: key:%s, value: %A" key d 
 
// We can play with different ways to get these data. 
 
open Microsoft.FSharp.Control;
 
let getAllDataMap testData = 
    testData |> Seq.map (fun (fst, _) -> getData cacheClient fst "TestRegion" )
 
let getAllDataParallel testData = 
    testData |> Seq.map (fun (fst, _) -> async { return getData cacheClient fst "TestRegion" })
            |> Async.Parallel
            |> Async.RunSynchronously 
 
// And remove them from cache finally:
for i in 1 .. 10000 do
let key = sprintf "key%i" i
removeData cacheClient key "TestRegion" |> ignore
 
Parsed in 0.028 seconds at 41.63 KB/s

So now we can use PowerShell AppFabric management commands from F# and use cache API to put and get simple data. Next time I’m going to play with more advanced cache API (notifications etc.) and real database data.

Usually you can improve performance and scalability of distributed application using in-memory cache data. Windows Server AppFabric recently released by Microsoft includes distributed cache module formerly known under codename “Velocity”. It is a distributed in-memory application cache platform for developing scalable, available, and high-performance applications. AppFabric fuses memory across multiple computers to give a single unified cache view to applications. Applications can store any serializable CLR object without worrying about where the object gets stored. Scalability can be achieved by simply adding more computers on demand. The cache also allows for copies of data to be stored across the cluster, thus protecting data against failures. It runs as a service accessed over the network.

Installation and configuration went very smoothly, Microsoft documentation on setup and configuration is quite good.

I set up AppFabric on my laptop running 64-bit version of Windows 7 without any problems.

I planned to play with Cache API using F# interactive – a great tool available in Visual Studio 2010 allowing quickly prototype and test F# code.

Data stored in AppFabric cache are partitioned using named memory caches which could be created by PowerShell commands – PowerShell is the main tool for AppFabric administration tasks. Strangely enough PowerShell command is the only way to create new named cache on the server (there is no .NET API for this purpose) so I had to learn how to call PowerShell commands from F#. After some googling I found the great blog post by Stephen Kaufman “Calling PowerShell from .NET” which had exactly what I needed but he used C#. Both C# and F# are .NET languages so it shouldn’t be very hard to translate code from one to another. So I created a couple of functions to call PowerShell commands from F# and tried them in F# interactive.

F#, using GeSHi 1.0.8.8
// We need to refer PowerShell API assembly
#r @"C:\Program Files (x86)\Reference Assemblies\Microsoft\WindowsPowerShell\v1.0\System.Management.Automation.dll"
 
open System.Management.Automation
open System.Management.Automation.Runspaces
 
let invokePsCacheCommand cmdName (parNameVal: (string * obj) list) =
    let state = InitialSessionState.CreateDefault()
    // Import PowerShell AppFabric modules
    [|"DistributedCacheAdministration"; "DistributedCacheConfiguration"|]  |> state.ImportPSModule 
    state.ThrowOnRunspaceOpenError <- true
    let rs = RunspaceFactory.CreateRunspace(state)
    rs.Open()
    // Create PowerShell command pipeline
    let pipe = rs.CreatePipeline()
    pipe.Commands.Add(Command("Use-CacheCluster"))
    let cmd = new Command(cmdName)
    // Add command parameters as name-value pairs
    parNameVal |> List.iter (fun (name, value) -> cmd.Parameters.Add(CommandParameter(name, value)))
    pipe.Commands.Add(cmd)
    // And invoke commands
    pipe.Invoke()
 
let createCache cacheName = 
    [("Name", cacheName); 
     ("Expirable", box false)] |> invokePsCacheCommand "New-Cache"
 
let removeCache cacheName = 
    [("Name", cacheName)] |> invokePsCacheCommand "Remove-Cache"
 
let exportCacheConfig fileName = 
    [("File", fileName)] |> invokePsCacheCommand "Export-CacheClusterConfig"
 
Parsed in 0.026 seconds at 51.22 KB/s

Now I can try to create my first named cache from F# interactive:

createCache "MyCache"

I selected this string and hit Alt-Enter to execute it in F# Interactive window and immediately got a cryptic message: “The specified module 'DistributedCacheAdministration' was not loaded because no valid module file was found in any module directory.” After a short internet search I found this post by Ron Jacobs. It seems that I’ve got this error because I’m using 64-bit version of AppFabric but VisualStudio runs Fsi.exe as 32-bit process. Am I out of lack and cannot use F# interactive to run PowerShell commands? No. It seems that in quickly expanding F# community one can find the answer to almost any problem:) Here it is: “Making the FSharp interpreter (fsi) run in 64bit!” I made all woodoo magic procedures described in this article and finally got sweet picture in power shell command window:

In the next part I’ll describe how to use cache API to store and retrieve data using F#.