Last post Jun 27, 2007 04:46 AM by statemirror
Jun 27, 2007 04:46 AM|statemirror|LINK
Alfavit releases StateMirror 1.2 - a next-generation alternative to the .NET session state management and a comprehensive solution for distributed application object caching.
It is a well known problem, that there’s no fast, failover
- enabled mechanism in ASP.NET, which would allow developers to store user session - specific information on the server side.
When it comes to supporting an uptime-demanding application on a web farm, there are two options offered by Microsoft: either use a dedicated Session State server, or a SQL Server.
The former immediately becomes a single point of failure.
The latter is slower and more resilient to failures, however solving the problem of it becoming a single point of failure requires setting up a SQL Server Cluster, which is quite expensive, not trivial to configure and maintain.
One way of working around this problem is to use a client side technology (some variant of forms or cookie-based storage) and to push the state of the application to the browser.
This works well when the amount of data to store in the user’s session is small.
However as the size of data grows, it becomes more and more expensive to keep sending it back and forth over the wire.
It’s possible to use different variations of client side in-memory storage, but it all comes down to the amount of data sent over the wire translating into client side performance.
Another important consideration here is the security of state data being sent over the wire with each request.
The risk may be reduced by encrypting the data or using HTTPS and reducing performance even further, or let the data be transmitted unencrypted, which may pose certain security and privacy threats.
StateMirror (http://www.statemirror.com) solves these problems by offering a state of the art technology solution complimenting server-side storage mechanisms provided by Microsoft.
The central tenant of StateMirror technology is the concept of “mirrored state servers”.
Each of the mirrored servers is implemented by a Windows service that can run on any web server or a stand-alone dedicated server, and can store session data similarly to the standard ASP.NET State Service.
The difference is that all Mirrored State Servers in the web farm work in sync and seamlessly synchronize on all StateMirror servers.
The client application accesses StateMirror servers via the standard .NET Session interface, which means that no programming is required to integrate StateMirror into an application,
which already uses .NET Session State. Enabling the use of StateMirror in a .NET application is as simple as adding one line of text into the standard web.config configuration file.
Service configuration is simplified by a user-friendly GUI application.
And here is the more exciting part, where StateMirror goes beyond what.NET offers today.
A bit of technical background.
ASP.NET applications have the ability to store cached data (as objects) in the application-wide cache, also known as Application.Cache.
This cache is accessible to application code at all times, regardless of which user’s request is being processed, thus being not session specific.
It is a convenient mechanism for storing frequently used application-wide data, especially the types of data which are time consuming to rebuild at run time.
A way to see where such an application-wide cache can be used is to imagine a home page of a web site, which displays a list of currently logged in users.
If the number of requests for the home page is high and the application runs on a web-farm, it is logical to assume that the list is cached across all the front end boxes allowing for better performance. Every time a user logs in, the
list updates; however once the server has updated its list of users, other servers still maintain the previous, outdated version of the list.
Now the problem is: how do other servers in the web farm find out about the change?
Unless they do, in an equally load balanced web farm users might see inconsistencies when refreshing the page.
The proper solution here is to synchronize caches on all servers once the data changes.
.NET 2.0 offers a standard way of doing that – Cache Dependency.
It’s possible to set a dependency on a SQL table and get the application notified when changes occur.
However for a frequently requested web resource this puts high demands on the SQL server, which further reduces performance and scalability of the application.
Other kinds of implementations may help in solving this problem: regular cache updates from the database, custom cache refresh mechanism across all front end servers and so on
– each has its advantages and disadvantages. All of them have one thing in common: custom implementation.
This is labor intensive, bug prone and requires solving the same problem again and again in every application you build.
Here’s where StateMirror comes to the rescue.
Similarly to how it allows to automatically synchronize user session data, it can also synchronize application caches on web farm servers.
It does that seamlessly, and is trivial to integrate – developers don’t need to write any extra code, all they need to do is assume that application cache data is always up to date and available to be retrieved from the cache.
Now the proof.
StateMIrror has been tested on some of highly trafficked web sites.
Let’s take Iceportal, with over 300,000 page views per day and over 1 million unique users per month requesting site content on a 3front-end server web farm.
StateMirror has proven to be reliable and scalable State Management Solution ensuring consistency of user state data and helping to achieve uptime greater than 99.99% .
In summary, this is how web-enabled applications with high availability requirements will benefit from StateMirror:
- all session state data is stored in memory for performance;
- multiple StateMirror servers can be added and automatically discovered as needed for scalability and high availability;
- easy installation, GUI monitor application, centralized event logging;
- support for .NET 1.1 and 2.0.
See for yourself how StateMirror can take your web solution to the next level of availability, scalability, performance and manageability. Download a trial version and follow simple
steps of the Users Guide to integrate it into your application – in just a few hours you will be running on this state of the art technology.
For more information, please visit http://www.statemirror.com.