Welcome!

You will be redirected in 30 seconds or close now.

ColdFusion Authors: Yakov Fain, Maureen O'Gara, Nancy Y. Nee, Tad Anderson, Daniel Kaar

Related Topics: ColdFusion

ColdFusion: Article

So You Want to Manage a Session on Load-Balanced Servers?

So You Want to Manage a Session on Load-Balanced Servers?

Recently I was tasked with converting a ColdFusion application to run on a ClusterCATS Web server cluster. Many questions that hadn't been addressed in the initial design of the application arose during this process. As I resolved each of the problems, I began thinking that other developers might benefit from my experience if I were to document the process, address the issues and write a "white paper." The result is this article, which I hope will assist ColdFusion developers in developing or converting a CF-based application to support "client state management" (see sidebar) in a clustered server environment.

Some of you may never run into the problems that can occur when an application is developed using session variables for client state management. Moreover, this article isn't intended to make "converts" out of developers wishing to use session variables. Every application and situation is unique (that's what makes application development so much fun, right?). Not all situations call for the changes I'm going to discuss in detail here. It's up to you, as a developer or project leader, to decide whether your application will be designed to use client or session variables to manage client state; this article will arm you with facts that can help you make an informed decision.

Assumptions
I'm going to assume you're familiar with the basic concepts of ColdFusion programming, including setting variables, outputting variables to a Web page and understanding variable "scope." I'll also assume you understand simple database transactions like updating, selecting, inserting and deleting data; basic database administration on your chosen database platform; and basic database terminology. It will also help for you to be familiar with ColdFusion Administrator and you certainly should have a working knowledge of your selected operating system, Web server and clustering software.

This article targets users of Microsoft SQL Server 7 with Enterprise Manager, ColdFusion 4+, Windows NT, IIS and ClusterCATS (included with CF Enterprise Edition). However, with knowledge of your particular applications, the steps outlined here can be applied to almost any combination of operating system, database platform, Web server and clustering technologies.

"State of the Union"
It's probably safe to say that most CF developers start out using session-scoped variables to manage client state. Session variables are fast and easy to use. In addition, there seems to have always been some confusion over the differences between client and session variables. Since session variables are most often discussed in the newsgroups, and are most frequently found in the various code examples in help screens, newsgroups and books, the implementation of session variables can be considered the most common method of client state management for new to intermediate CF developers.

Furthermore, it's also safe to say that "newbie" CF developers have no inherent need to work with any other method of client state management, since they're working primarily within a single-server environment. Since a single-server development or production platform poses no problems for developers using session variables for client state management, the session scope is an excellent choice.

A Clustering "Primer"
There are times, however, when using session variables can get you into trouble - specifically when running the application in a clustered-server environment. Before I address this problem, let's talk about what a clustered server environment really is. While an in-depth discussion of clustering is beyond the scope of this article, I will offer this brief "primer."

Configuring a cluster involves installing either hardware or software into the network infrastructure that will load-balance a Web site or Web application across multiple servers. This provides scalability: as usage of a Web site or Web application grows and server traffic increases, more horsepower can easily be added to the mix to compensate.

This article considers a specific and common configuration: ColdFusion 4+ with BrightTiger's ClusterCATS. In the CF/ClusterCATS configuration, the ClusterCATS software component connects two or more ColdFusion Web servers together, allowing them to share the work of processing and serving up Web pages. It also provides an element of fault tolerance; should one of the machines become unavailable (because of a hardware, software or network failure), the "load" is shifted to the remaining machine(s). All of this clustering functionality is (or should be!) transparent to the users.

There are two primary means of balancing the load across a cluster: "session-sensitive" and "true" load balancing. Session-sensitive load balancing occurs when a visitor is initially load-balanced to a particular server based upon traffic at that particular moment, then remains on that server for the duration of his or her session - even if another server in the cluster eventually carries a lighter load (see Figure 1). True load balancing occurs when, at any time during the session, a visitor may be receiving files from any server in the cluster. This has the advantage of balancing the load actively, using all servers in the cluster at all times for all visitors (see Figure 2).

ClusterCATS, as well as other clustering technologies, can function in both the true and session-sensitive modes I've described. With ClusterCATS it's as easy as changing one checkbox.

Some of you may disagree with my use of the somewhat biased term true load balancing. Your own experience may be that session-sensitive load balancing is just as good a choice when it comes to ease of use and performance.

I agree with you, up to a point: with a high-volume site, a session-sensitive clustering configuration might "all average out" and provide good performance for all the users. At any given moment a few servers may actually have more load than others, because more users have started a session and remained on a particular server longer. However, with a great many users, it might balance out in the end, without any noticeable performance issues. But there's no guarantee.

The Problem with Session-Scoped Variables in the Cluster
The heart of the problem is this: with each shift to a different server in a cluster, CF session variables are "lost." For example, if I log in to your application or Web site and end up on server www1 and you have set a session variable called "Session. IsLoggedIn" to keep track of me, that variable will be stored in the memory of the server www1. Since there's no central memory repository available to CF, if at any time during my session I'm load-balanced to server www2, that session variable will be lost because it doesn't exist in the memory of server www2.

As far as www2 is concerned, I never logged in. Most likely, your application will deal with me just like any other user who's trying to load a page that requires a login: it'll redirect me to a login screen instead of showing me the page. But as a user who already logged in when I was on www1, I won't be at all pleased. To put it mildly, this isn't good. Leave such a problem unresolved and your users will probably want to know where you live!

You might ask, "So what's the big deal?" Why not just use session-sensitive load balancing and keep the user on a particular server, with all their session variables stored in that server's memory for the length of their session? Wouldn't that be easiest?

Here's where I stand by the term true load balancing and can show it to be a better configuration. Session-sensitive load balancing has one very real pitfall that occurs when a user has been load-balanced to a particular server and has established a session there, but that server then becomes unavailable. Should that happen, the user will inevitably be shifted to another server in the cluster, with the added hassle of losing their session variables in the process. You'll need to change your application code to resolve this problem, so why not use the more robust (true) load-balancing solution as well?

As you may have guessed by now, I'm no advocate of session-sensitive load balancing. I think of it this way: the expense of hardware, software and configuration of a server cluster can be justified only by gains in performance and failover protection; session-sensitive load balancing can potentially be an obstacle to both of those goals, while true load balancing actively involves all of the servers in your cluster on a continuing basis, fully achieving both of those goals. Most important, use of session-sensitive load balancing inappropriately encourages the use of session variables, which will quickly detract from the user-transparent failover abilities of the clustering solution.

The bottom line? With either method of load balancing, use of session variables is unacceptable. In reality, it doesn't matter which load-balancing solution you choose - as long as you don't use session variables, either one will work. However, it's my belief that if you really want to gain the full benefits of server clustering, you'll want to compose your ColdFusion application to support true load-balancing, while still being able to maintain client state. That's what this article is about.

Using Client-Scoped Variables for Application Scalability
Since session variables can only be stored in server RAM and since application and server variables aren't user-specific, we can't use those scopes to maintain client state in a load-balanced environment. We must therefore turn to client-scoped variables to solve this problem. More specifically, these client-scoped variables need to be stored in a specially designated database as opposed to the server registry (the default option for client variables). In this article I'm going to provide the systematic process for designing or converting a CF application to run on a Web server cluster, using database-stored client-scoped variables.

Configuration Outline
There are three basic areas you'll need to address in order to implement database-stored client-scoped variables within your application. The three steps are as follows:
1. Database configuration: Since all members of your ColdFusion Web cluster can "see" your database server cluster, this is where your client variables will be stored. You'll create a database on your server for use as the client variable repository (CVR).
2. CF server(s) configuration: All the servers in your cluster will need to be configured not to store client variables in the registry, but to use instead the database you'll have configured in Step 1. This involves using the ColdFusion Administrator to create an ODBC data source and the connection to your CVR. I'll also describe in detail how to disable the session-aware load-balancing feature within ClusterCATS.
3. Application design/conversion: If you'll be developing a new application, this step will help you design your application to support server clustering right from the start. If you have an existing application, this step will describe the changes that are required to make your application "clustering friendly."

If your application is already running in some form and you're tasked with planning or implementing a conversion, I would strongly recommend that you verify that all current features of your application are in working order prior to beginning this process. If you know everything worked before you started, you'll have a much easier time determining what problems may have surfaced as a result of the conversion process.

STEP 1: Database Configuration (MS SQL Server 7, Enterprise Manager)
This is a very easy step. It basically involves creating an empty database to run in parallel with the database(s) currently being accessed by your CF site. Storing client variables in tables of your existing database isn't recommended or supported.

You'll need to know the name of the SQL server that's being made available to the CF cluster and you'll need the appropriate permissions to create a new database on that SQL server. Configuring access to your SQL server via Enterprise Manager is beyond the scope of this article - you'll need to refer to your SQL server Books Online or your DBA for assistance.

Here is how to complete Step 1:

a. Start Enterprise Manager (usually found by clicking Start | Programs | Microsoft SQL Server 7.0 | Enterprise Manager).
b. Drill down through your configured SQL server groups and your chosen SQL Server until you see the Databases folder.
c. Right-click on the Databases folder, and choose New Database. The Database Properties window will appear.
d. Keep all default values in this window, and enter a name for your new database (in this example, "CVR"). You can call this database anything you wish and create additional separate databases for each application that will be using DB-stored client variables. Click OK to create the database.
e. You can configure additional options for this database later, including a regular backup/maintenance plan. (That's a nice bonus!)
f. Don't add any tables or other objects to this database until you've completed all the steps in this document. The required objects will be automatically created in later steps, after which you may add additional objects such as stored procedures, views or additional tables. However, I do recommend that you keep this database optimized and try your best to minimize the overhead created by adding too many objects or functions.

STEP 2: Configuration of ColdFusion Server
Note: Processes 2.1 and 2.2 will need to be carried out on each server in your cluster - with the exception of step (e) in process 2.2. By following these instructions, you'll configure your servers to use the database created in Step 1 above to store client variable data.

  • 2.1: Create the data source.

    For this step you'll need full access to the ColdFusion Administrator application on each server in the cluster. Here's what to do in detail:

    a.  Start the ColdFusion Administrator (usually found by clicking Start | Programs | ColdFusion Server 4.x | ColdFusion Administrator).
    b.  Log in using the password for administrator access that you chose when CF Server was installed.
    c.  Click on ODBC under the Data Sources section on the left sidebar.
    d.  Type the data source name ("CVR" in this example), choose the ODBC Driver ("Microsoft SQL Server Driver" in this example) and click the Add button.
    e.  Enter the name or IP address of the database server in the Server field.
    f.  In the database field enter the name of the database you created in Step 1 ("CVR" in this example).
    g.  Click the CF Settings button and complete the username and password fields to access this database.
    h.  Make sure Maintain Database Connections is checked.
    i.  Click the Create button. After the data source is created you should see your list of data sources again, with "verified" next to the data source you just created. If you don't see "verified," you must take whatever steps are necessary until this server is able to connect to the data source. The connection must be verified before you can continue.

  • 2.2: Configure client variable storage.

    Now that you've created the data source, you will configure the server(s) to use that data source to store client variables.Here's how to do so in detail:

    a.  Under the Server category in the left sidebar, click Variables.
    b.  You will see a select box at the top, under Name. Choose the data source you created above ("CVR" in this example) from the select box, and click Add.
    c.  On the page that loads next, choose the number of days you wish to have client variables stored in your database. The default is 10 days.
    d.  For higher-traffic sites, you may wish to select Disable Global Client Variable Updates. In the beginning, try leaving them enabled; if performance suffers, you can place a check in this box later. Keep in mind that if you write code that depends upon the automatic updating of such client variables as "LVISIT" (the last date/time the client with that CFID loaded a page) and "HITCOUNT" (the number of page impressions by a particular client), your code will break if you disable global updates later.

    e.  (This is a very important step.) If this is the first server you are configuring, you need to leave the checkmark next to Create Client Database Tables. This will create the necessary objects in the empty database you created in Step 1. However, if this is not the first server, you must remove the checkmark and turn this feature off; otherwise you will receive an SQL error indicating that the tables already exist and therefore could not be created. If you receive this error, your configuration will fail.
    f.  Click on Create. Your Client Storage area will appear in the list on the resulting page.
    g.  Repeat these steps for every server in your cluster, noting the exception in step (e) above.

  • 2.3: Configure ClusterCATS.

    This is not by any means an in-depth discussion on the setup and configuration of ClusterCATS; it's only a specific set of steps to accomplish the goal of enabling true load balancing within the cluster. If you're using a different clustering solution, contact your vendor or system administrator for help in finding a similar setting.

    The detailed steps are as follows:

    a.  Open the ClusterCATS explorer (usually found by clicking Start | Programs | BrightTiger | ClusterCATS Explorer).
    b.  In the left pane you'll see Cluster Manager. Beneath the Cluster Manager you should see your configured cluster(s).
    c.  Right-click on the cluster your application is running under and choose Properties.
    d.  Click the Administration tab at the top of the window that appears.
    e.  Under the section labeled Session State Management, turn off Enable Session Aware Load Management, then click OK (see Figure 3).

    Your cluster will now serve pages from any server at any time, rather than "parking" users on a particular server for their entire session.

    The list below references other server settings that you may wish to adjust, depending upon your situation: 1. Default Client Variable Storage (Server category, Variables page): The default is Registry. If you want all the Client variables for all applications to use the same central database, change this from Registry to the data source you created (CVR). If you choose to leave this as Registry, you must make sure all of your CFAPPLICATION tags specify the CLIENTSTORAGE attribute (see next section). The registry, just like server RAM, is specific to each server, making it inappropriate for storing client variables in a cluster.

    2. Session and Application Variables (Server category, Variables page): You may wish to disable session and application variables, so that if you accidentally write them into your application, you'll receive an error rather than allowing the application to function. Since session and application variables are not centrally stored, if you should accidentally use session and application variables, your application will function on the cluster but with undesirable results. Disallowing session and application variables adds another level of protection.

    STEP 3: Application Design Conversion
    This will probably be the most challenging step. Since I can't be there to help you with your code, I can't provide screenshots and other helpful tools to aid you in the design or conversion of your application to use client variables. However, there are some basic bits of code that you'll need to use, starting with the CFAPPLICATION tag.

    The CFAPPLICATION Tag
    This is an important setting. In every Application.cfm in your application (if you are using Fusebox, chances are this setting will exist in your "app_Globals.cfm" file), you should have a CFAPPLICATION tag. You need to make sure that you have enabled client variables for your application, and turned off the ability to use session variables in each instance of the tag. A sample CFAPPLICATION tag, using our database created above as an example, would look like this:

    <CFAPPLICATION
    NAME="YourAppName"
    CLIENTMANAGEMENT="Yes"
    SETCLIENTCOOKIES="Yes"
    CLIENTSTORAGE= "CVR">

    Make sure you specify a separate name for each application running on your cluster - the CVR database uses that name to keep client variables unique, should you choose to store all client variables for all applications in one database (i.e., using the Default Client Variable Storage location in the ColdFusion Administrator).

    It remains a matter of choice whether or not you will enable "SETCLIENTCOOKIES" - the use of cookies makes coding easier because you don't need to pass CFID and CFTOKEN in the URL throughout your application. Passing CFID and CFTOKEN in the URL presents a couple of issues:

  • You could get a potential problem with a user trying to "jump sessions" by hacking different numbers into the CFID/CFTOKEN variables.
  • CFID and CFTOKEN can cause problems when someone wishes to bookmark a page in your application.

    Personally, I require cookies on all of my sites and then provide adequate security and cookie information to the users who are refusing or unable to accept cookies so they know why we require them. I prefer setting CFID and CFTOKEN to a "session-only" cookie so that the session is destroyed when users close their browsers:

    <CFCOOKIE NAME="CFID" VALUE="#CFID#">
    <CFCOOKIE NAME="CFTOKEN" VALUE="#CFTOKEN#">

    I then detect whether users are able/willing to accept cookies, and redirect them to an information page if they are not, using JavaScript:

    <SCRIPT>
    document.cookie = 'CookiesEnabled=1';
    if (document.cookie == ''){
    document.location.href='myCookieInfoPage.htm';}
    </SCRIPT>

    You can choose any method you like to detect whether browser cookies are enabled. (First you'll need to decide for yourself whether or not cookies should be a function of your application, based upon your user demographics and other factors.)

    Notice that in the CFAPPLICATION tag above, we have set the value for CLIENTSTORAGE equal to the data source name that we configured in Step 1. If this is not specified, and any one of the servers in the cluster is not configured to use your database as the Default Client Variable Storage location, then you may get unexpected results because your client variables will end up someplace other than in your database (most likely the registry, which is the default location). In my opinion, it's safest to distinctly specify the CLIENTSTORAGE value.

    Existing Session Variable Code
    If you're designing a new application, simply set and retrieve all the variables that you would have scoped as session, using the client scope instead. Some examples:

    <CFSET Client.IsLoggedIn = 1>
    <CFOUTPUT>#Client.IsLoggedIn#</CFOUTPUT>
    <CFIF NOT Client.IsLoggedIn>
    <CFLOCATION
    URL="notloggedin.cfm"
    addtoken="no">
    </CFIF>

    If you're converting an existing application - back up your application first please! - perform a global, case-insensitive find (notice I did not say replace!) for all occurrences of "Session." in all of your ColdFusion templates within your application. Inspect each occurrence to make sure that the text string "Session." is actually referring to a session variable, making notes of the exceptions. (For example, a sentence on your template might read "Click Log Out to terminate your session." With a global replace, this would end up reading "Click Log Out to terminate your Client."!) While this process can be tedious (checking all the session variables in your application before replacing them all could mean opening almost every page in the application), it will be rewarding knowing exactly what has been changed when you do finally perform the global replace.

    After making note of the exceptions (if any), perform a global replace, replacing all occurrences of "Session." with "Client." Return to the pages where you noted exceptions and change them back to the proper text.

    Managing Session Timeout
    Client variables are set to expire after a certain number of days. This may not be appropriate for certain variables of your application. For example, perhaps your session variable for "IsLoggedIn" used to time out after 20 minutes because it was a session variable. If users closed their browsers without logging out (a common problem), you couldn't guarantee that they were logged out, but at least you'd know that eventually their session variable would expire after a reasonable time. In contrast, the default client variable setting would only remove the client variable after 10 days - they could go to your site or application and be logged in already, up to 10 days after they first logged in!

    If this is inappropriate for your application, there are a several options. In one application I designed, I actually ran two additional "hidden frames" in addition to the pages of the application. One loaded a page that kept the session alive using a META refresh tag (for user convenience - so they wouldn't time out as long as they kept their application open). The other frame loaded a page that contained some JavaScript. The script executed a logout routine and logged users out when they left the site or closed their browsers ("onUnload"). This is a very reliable method if you have some control over the user environment (this particular application ran on an intranet where Internet Explorer 5 with JavaScript and cookies was a requirement for the organization).

    Assuming that you don't have some kind of cosmic power over the browser and settings your site visitor chooses to use, you'll need to find another solution. The easiest one I can provide requires that either the Global Client Updates (Step 2.2 (d), above) is on, or that you are updating the client LVISIT data within strategic parts of your application. This way, if a certain period of time has elapsed (30 minutes in these examples) beyond their last page activity, the user is logged out by destroying their client variables (see Listing 1).

    The code in Listing 1 needs to be run at every page impression (usually included in app_Globals.cfm or Application.cfm) or at least at points where you wish to ensure that the user has remained "active." If you want to optimize this code, you can create a stored procedure for the query and run it on the server side (see Listing 2).

    After running these queries/stored procedures, you may wish to CFIF the primary client variable you're using to track login and reset other client variables if the variable doesn't exist or is set to the wrong value. In addition, you may not wish to actually destroy all the client variables as I have done above - instead you may just wish to set one particular variable to a certain value. Adjust the examples above, or come up with your own.

    A colleague suggested another method, in which the IsLoggedIn client variable is actually set to the date/time of login (instead of "1" or "0") and is then updated at each page request during a logged-in session. That value is then compared to a timeout period and destroyed if the user has been idle for too long. When the variable is destroyed, the rest of the app validates the login status and takes appropriate action. This method works just as well and is one among many other options, I'm sure. There's even a CF function available to you should you need it, "DeleteClientVariable()". The bottom line is, choose whichever methods are the most appropriate for your situation.

    Once you've adjusted all the code necessary...test, test and then test some more. Test your timeout and test every module. Don't roll out your code until everything works the way it did before you started.

    Choosing a Client State Management Method
    As is the case with any application development, it's important to understand the adverse consequences of creating an application without carefully considering what the final production environment may be in the future.

    In my view nothing drives this point home more clearly than the decision of whether to use client or session variables when creating a new CF application. If you create an entire application using session variables and suddenly it's brought to everyone's attention that the site is going to run in a load-balanced environment, you'll have a lot of rewriting and testing to do. Discussion of the final production environment during the planning phase of an application can help avoid that situation. It seems like a no-brainer, but warrants emphasis: it's a lot easier to build the application from the ground up to support the environment it will be running under, rather than rebuild it later.

    If it's determined that your application will never need to run in a load-balanced/clustered environment, then you'll probably lean more towards using session variables - you can bet that I do. The primary advantage that I can see in using session variables is lower database overhead. That's really the only major downfall of client variables - the need to access a database to use them. However, the stored procedure code I have provided in this article has made my own company's solutions very efficient and we've seen no degradation in performance. To paraphrase the philosophy of a great ColdFusion guru (thanks, Ben!): "It is scalable - it's all in how you code."

    An added benefit of storing those client variables in the database is that now they are available via standard queries, for reporting - I have even written a routine into one application that will kill users' sessions and disable their accounts with one click of a mouse should they be "misbehaving." Client variables make this and other user management and session reporting very easy.

    If you're expecting high traffic on your site or application, then you're already planning (or should be!) for some sort of load balancing to meet the demand. With good code, good clustering software, the right hardware and perhaps a clustered database server configuration, wrapping things up with good client state management will guarantee a good user experience with exceptional fault tolerance should anything go awry.

    Conclusion
    Other technologies can integrate into this method of managing client state, including the use of WDDX to store more complex user data across your pages. As always seems to be the case, the possibilities with CF are endless. The real point here is to be aware that the "Session Variables versus Clustered Servers" battle exists and to be ready to deal with it - whether on a new project or as someone responsible for retrofitting an existing application. Armed with this information, you'll be able to build clustering support into any application you're involved with and perhaps explore additional performance or timesaving methods of accomplishing these goals. Half of your success as a developer will always come from asking the right questions before you write a single line of code.

    If you should find some additional ways of extending the techniques I've discussed in this article, I'd be happy to hear from you.

    Special thanks go to:

  • Ralph Fiol www.mediaxxi.com
  • Hal Helms www.teamallaire.com/hal/
  • Val Agostino www.ebags.com
  • More Stories By Marc Funaro

    Marc Funaro is president of Advantex Technical Consulting Services (www.advantex.net), based in Norwich, New York. He is a graduate of the State University of New York at Buffalo. Advantex specializes in highly focused Internet-related services including on-site and remote database and Web-based application and optimization.

    Comments (3) View Comments

    Share your thoughts on this story.

    Add your comment
    You must be signed in to add a comment. Sign-in | Register

    In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


    Most Recent Comments
    Tom 03/03/05 01:34:06 PM EST

    The limitation of client variables as to the type of data they can store can be solved with the help of WDDX. However, I question the speed of the "client" solution. I didn't run any tests to prove my point (author also didn't run any to show his point) but client variables are in DB while session/application/server are in server's RAM. Thus, access time for even simple client variables is quite greater than access time for session variables. With complex client variables add time to parse say WDDX structure. Also, storing say CFC in client scope would be rather challenging and I think a bit pointless from performance standpoint.

    I am leaning toward RAM based solution with session based load balancing as superior in terms of speed and code simplicity to author proposed client based solution for setups that use more than few session management variables per page. I guess one would have to do a lot of testing before deciding which solution is faster given their particular piece of code.

    Shelley Browning 02/24/05 01:10:04 PM EST

    There are situations in which session variables are necessary over client variables. Remember that client variables only store simple data types (strings & numbers), where as session variables can store complex data types (arrays, queries, structures). Each application is different in the level of complexity that is required. Having the option to use client or session variables allows for great flexibility in the method of session management and load balancing.

    Dharmendar Kumar 03/30/03 11:50:00 AM EST

    I do understand that using client-variables are a better option for clustering in most cases. But there are cases when session-based management is a better option.
    For example: when users can upload files (images, docs, etc) thro. a web interface. In this case the file will be uploaded to the hard-drive of, say the first server. Now if sessions are used then it ensures that the user is sent to that same server when he gets the confirmation page - and he can 'see' his uploaded file. In such a case if one is using client-variables, then obviously there will be instances when user uploads a file and then is not able to 'see' the uploaded file. (I am assuming that files are duplicated from one server to the other once every few minutes; and not uploaded to both the servers).

    If I am wrong here; or if there is a way to upload the files on both servers instantaneously do let me know.

    Thanks,
    Dharmendar Kumar

    @ThingsExpo Stories

    ARMONK, N.Y., Nov. 20, 2014 /PRNewswire/ --  IBM (NYSE: IBM) today announced that it is bringing a greater level of control, security and flexibility to cloud-based application development and delivery with a single-tenant version of Bluemix, IBM's platform-as-a-service. The new platform enables developers to build ap...

    The BPM world is going through some evolution or changes where traditional business process management solutions really have nowhere to go in terms of development of the road map. In this demo at 15th Cloud Expo, Kyle Hansen, Director of Professional Services at AgilePoint, shows AgilePoint’s unique approach to dealing with this market circumstance by developing a rapid application composition or development framework.
    "BSQUARE is in the business of selling software solutions for smart connected devices. It's obvious that IoT has moved from being a technology to being a fundamental part of business, and in the last 18 months people have said let's figure out how to do it and let's put some focus on it, " explained Dave Wagstaff, VP & Chief Architect, at BSQUARE Corporation, in this SYS-CON.tv interview at @ThingsExpo, held Nov 4-6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
    The major cloud platforms defy a simple, side-by-side analysis. Each of the major IaaS public-cloud platforms offers their own unique strengths and functionality. Options for on-site private cloud are diverse as well, and must be designed and deployed while taking existing legacy architecture and infrastructure into account. Then the reality is that most enterprises are embarking on a hybrid cloud strategy and programs. In this Power Panel at 15th Cloud Expo (http://www.CloudComputingExpo.com), moderated by Ashar Baig, Research Director, Cloud, at Gigaom Research, Nate Gordon, Director of T...
    The Internet of Things is not new. Historically, smart businesses have used its basic concept of leveraging data to drive better decision making and have capitalized on those insights to realize additional revenue opportunities. So, what has changed to make the Internet of Things one of the hottest topics in tech? In his session at @ThingsExpo, Chris Gray, Director, Embedded and Internet of Things, discussed the underlying factors that are driving the economics of intelligent systems. Discover how hardware commoditization, the ubiquitous nature of connectivity, and the emergence of Big Data a...
    SYS-CON Events announced today that Windstream, a leading provider of advanced network and cloud communications, has been named “Silver Sponsor” of SYS-CON's 16th International Cloud Expo®, which will take place on June 9–11, 2015, at the Javits Center in New York, NY. Windstream (Nasdaq: WIN), a FORTUNE 500 and S&P 500 company, is a leading provider of advanced network communications, including cloud computing and managed services, to businesses nationwide. The company also offers broadband, phone and digital TV services to consumers primarily in rural areas.
    “In the past year we've seen a lot of stabilization of WebRTC. You can now use it in production with a far greater degree of certainty. A lot of the real developments in the past year have been in things like the data channel, which will enable a whole new type of application," explained Peter Dunkley, Technical Director at Acision, in this SYS-CON.tv interview at @ThingsExpo, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
    SYS-CON Events announced today that IDenticard will exhibit at SYS-CON's 16th International Cloud Expo®, which will take place on June 9-11, 2015, at the Javits Center in New York City, NY. IDenticard™ is the security division of Brady Corp (NYSE: BRC), a $1.5 billion manufacturer of identification products. We have small-company values with the strength and stability of a major corporation. IDenticard offers local sales, support and service to our customers across the United States and Canada. Our partner network encompasses some 300 of the world's leading systems integrators and security s...
    DevOps Summit 2015 New York, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that it is now accepting Keynote Proposals. The widespread success of cloud computing is driving the DevOps revolution in enterprise IT. Now as never before, development teams must communicate and collaborate in a dynamic, 24/7/365 environment. There is no time to wait for long development cycles that produce software that is obsolete at launch. DevOps may be disruptive, but it is essential.
    "People are a lot more knowledgeable about APIs now. There are two types of people who work with APIs - IT people who want to use APIs for something internal and the product managers who want to do something outside APIs for people to connect to them," explained Roberto Medrano, Executive Vice President at SOA Software, in this SYS-CON.tv interview at Cloud Expo, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
    Nigeria has the largest economy in Africa, at more than US$500 billion, and ranks 23rd in the world. A recent re-evaluation of Nigeria's true economic size doubled the previous estimate, and brought it well ahead of South Africa, which is a member (unlike Nigeria) of the G20 club for political as well as economic reasons. Nigeria's economy can be said to be quite diverse from one point of view, but heavily dependent on oil and gas at the same time. Oil and natural gas account for about 15% of Nigera's overall economy, but traditionally represent more than 90% of the country's exports and as...
    The Internet of Things is a misnomer. That implies that everything is on the Internet, and that simply should not be - especially for things that are blurring the line between medical devices that stimulate like a pacemaker and quantified self-sensors like a pedometer or pulse tracker. The mesh of things that we manage must be segmented into zones of trust for sensing data, transmitting data, receiving command and control administrative changes, and peer-to-peer mesh messaging. In his session at @ThingsExpo, Ryan Bagnulo, Solution Architect / Software Engineer at SOA Software, focused on desi...
    "At our booth we are showing how to provide trust in the Internet of Things. Trust is where everything starts to become secure and trustworthy. Now with the scaling of the Internet of Things it becomes an interesting question – I've heard numbers from 200 billion devices next year up to a trillion in the next 10 to 15 years," explained Johannes Lintzen, Vice President of Sales at Utimaco, in this SYS-CON.tv interview at @ThingsExpo, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
    "For over 25 years we have been working with a lot of enterprise customers and we have seen how companies create applications. And now that we have moved to cloud computing, mobile, social and the Internet of Things, we see that the market needs a new way of creating applications," stated Jesse Shiah, CEO, President and Co-Founder of AgilePoint Inc., in this SYS-CON.tv interview at 15th Cloud Expo, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
    SYS-CON Events announced today that Gridstore™, the leader in hyper-converged infrastructure purpose-built to optimize Microsoft workloads, will exhibit at SYS-CON's 16th International Cloud Expo®, which will take place on June 9-11, 2015, at the Javits Center in New York City, NY. Gridstore™ is the leader in hyper-converged infrastructure purpose-built for Microsoft workloads and designed to accelerate applications in virtualized environments. Gridstore’s hyper-converged infrastructure is the industry’s first all flash version of HyperConverged Appliances that include both compute and storag...
    Today’s enterprise is being driven by disruptive competitive and human capital requirements to provide enterprise application access through not only desktops, but also mobile devices. To retrofit existing programs across all these devices using traditional programming methods is very costly and time consuming – often prohibitively so. In his session at @ThingsExpo, Jesse Shiah, CEO, President, and Co-Founder of AgilePoint Inc., discussed how you can create applications that run on all mobile devices as well as laptops and desktops using a visual drag-and-drop application – and eForms-buildi...
    We certainly live in interesting technological times. And no more interesting than the current competing IoT standards for connectivity. Various standards bodies, approaches, and ecosystems are vying for mindshare and positioning for a competitive edge. It is clear that when the dust settles, we will have new protocols, evolved protocols, that will change the way we interact with devices and infrastructure. We will also have evolved web protocols, like HTTP/2, that will be changing the very core of our infrastructures. At the same time, we have old approaches made new again like micro-services...
    Code Halos - aka "digital fingerprints" - are the key organizing principle to understand a) how dumb things become smart and b) how to monetize this dynamic. In his session at @ThingsExpo, Robert Brown, AVP, Center for the Future of Work at Cognizant Technology Solutions, outlined research, analysis and recommendations from his recently published book on this phenomena on the way leading edge organizations like GE and Disney are unlocking the Internet of Things opportunity and what steps your organization should be taking to position itself for the next platform of digital competition.
    The 3rd International Internet of @ThingsExpo, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that its Call for Papers is now open. The Internet of Things (IoT) is the biggest idea since the creation of the Worldwide Web more than 20 years ago.
    As the Internet of Things unfolds, mobile and wearable devices are blurring the line between physical and digital, integrating ever more closely with our interests, our routines, our daily lives. Contextual computing and smart, sensor-equipped spaces bring the potential to walk through a world that recognizes us and responds accordingly. We become continuous transmitters and receivers of data. In his session at @ThingsExpo, Andrew Bolwell, Director of Innovation for HP's Printing and Personal Systems Group, discussed how key attributes of mobile technology – touch input, sensors, social, and ...