Content-switching is an OSI layer 7 application switching technique, which in lamans terms means that it has access to the HTTP requests and responses of your application. By inspecting each request and response, it make decision on where to send those requests and how to handle responses.

HAProxy is an open source load balancing tool that also has the ability to implement content switching.

Proxies & Reverse Proxies

You might be familiar with a Proxy, which is basically something that sits between the client and the server. When the client makes a request it first goes through the proxy then to the server. The response from the server then goes back through the proxy  to the client. These are usually implemented by the client and completely transparent to the server. A great example of this is when someone configures their browser to use a proxy to access the internet, with a tool such as Tor.

A Reverse Proxy is the same thing except it acts on behalf of the server. One example of a Reverse Proxy is a load balancer, which receives requests from a users and usually proxies them to one of several backend servers. This process is completely transparent to the client. Content switching is also a form of Reverse Proxy.

Content-Switching Scenario

Let's say you're in charge of a large social bookmarking application, http://delicioso.com. The shelf life for that system has come to and end and you're team has decided to rewrite everything in Rails. It's going to take a long time to migrate everything over to the new application, and you want to reduce the risk involved with a huge release cycle. Instead you want to take an agile approach and roll out bits and pieces over time in the following order:

1. Configure HAProxy as a Reverse Proxy
2. Phase in user profiles - http://delicioso.com/profile/...
3. ...

For the purpose if this example, let's call the current application Legacy. Image your current infrastructure is setup like the following:

                        +-------------------+
                        |    example.com    |
  User  +---------->    |-------------------|
                        |     legacy:80     |
                        +-------------------+

Step 1: Configure HAProxy as a Reverse Proxy

The first step is to setup HAProxy to be reverse proxy for Legacy, so later we can implement content-switching. You'll need to have HAProxy installed.

                      +-------------------+
                      |    example.com    |
User  +---------->    |-------------------|
                      |    HAProxy:80     |
                      |     legacy:8001   |
                      +-------------------+

Here's the config file to configure HAProxy in this way:

global
  #debug                                   # uncomment to enable debug mode for HAProxy
 
defaults
  mode http                                # enable http mode which gives of layer 7 filtering
  timeout connect 5000ms                   # max time to wait for a connection attempt
                                           #  to a server to succeed
  timeout client 50000ms                   # max inactivity time on the client side
  timeout server 50000ms                   # max inactivity time on the server side
 
backend legacy                             # define a group of backend servers
  server legacy_server 127.0.0.1:8001      # add a server to this backend
 
frontend app *:80                          # define what port to listed to for HAProxy
  default_backend legacy                   # set the default server for all request

Step 2: Phase in User Profiles

All of your user's profile pages have a URL format as follows: /profile/username. Your team finished implementing this in the new Rails framework and it's time to roll it out. The rails app is running on port 8002.

                      +-------------------+
                      |    example.com    |
User  +---------->    |-------------------|
                      |    HAProxy:80     |
                      |     legacy:8001   |
                      |      rails:8002   |
                      +-------------------+

Here's the new config file for content-switching all requests starting with /profile to the new rails application

global
  #debug
 
defaults
  mode http
  option httpclose                         # close the tcp connection after every request
  timeout connect 5000ms
  timeout client 50000ms
  timeout server 50000ms
 
backend legacy
  server legacy_server 127.0.0.1:8001
 
backend rails                              # define a group of backend servers
  server rails_server 127.0.0.1:8002       # add a server to this backend
 
frontend app *:80
  default_backend legacy
  acl rails_path path_beg /profile         # acl rule for rails supported paths
  use_backend rails if rails_path          # use rails if the rules match.

Check out the HAProxy documentation for more keywords your can use to route requests. This was a pretty simple example, this get's more challenging when you need to handle session state across the legacy and new systems.

Just add the file attribute to the <appSettings> node in your web.config, and add a local.config file to the project root.

<!-- WEB.CONFIG -->
<configuration>
  ...
  <appSettings file="local.config">
    ...
  </appSettings>
  ...
</configuration>

<!-- LOCAL.CONFIG -->
<?xml version="1.0" encoding="utf-8"?>
<appSettings>
	<add key="MySQLConnectionString" value="..." />
</appSettings>

Now when your app loads, it will check to see if there's a local.config file relative to the web.config file. If there is a file, then it overrides any web.config settings it finds duplicates for in the local.config. If the local.config file does not exist, then it is ignored.

Pro tip: Keep local.config out of your code repo and boom! Easily manageable local dev environment settings.

See Also:

• MSDN: appSettings Element (General Settings Schema)

CMD + OPT + CTL + [F1 - F7]

{
	"pk": 1,
	"model": "core.wine",
	"fields": {
		"name": "Juan Gil",
		"vintage": 2009
	}
}

Here's the error I was getting:

Problem installing fixture '.../core/fixtures/initial_data.json': Traceback (most recent call last):
  File ".../python2.6/site-packages/django/core/management/commands/loaddata.py", line 169, in handle
    for obj in objects:
  File "...python2.6/site-packages/django/core/serializers/json.py", line 35, in Deserializer
    for obj in PythonDeserializer(simplejson.load(stream), **options):
  File "...python2.6/site-packages/django/core/serializers/python.py", line 84, in Deserializer
    Model = _get_model(d["model"])
TypeError: string indices must be integers

The fix was simple, wrap the object in an array.

[
	{
		"pk": 1,
		"model": "core.wine",
		"fields": {
			"name": "Juan Gil",
			"vintage": 2009
		}
	}
]

Found the fix thanks to the following StackOverflow post: http://stackoverflow.com/a/4939147

A Man's Secret - An Analogy

A man possess a secret book, which he cannot let anyone else know about. He decides the only way to keep the book truly secret is to memorize the entire thing and then bury the book so no one can find it. Later in his years he bears a son. Once his son grows old enough, the father digs up the book and begins having his son commit the entire book to memory. Years later, he has his son rewrite the entire book cover to cover from memory on paper. When the son successfully completes the task, and the father is satisfied that his son truly has the book memorized in it's entirety, the book and the copy of the book the son just wrote are thrown into a fire, completely eliminating any evidence that the book actually existed. A few years later the father dies, leaving the son on his own, with the book committed to memory.

This is similiar to how a javascript closure works. See the following code.

Code Example

var father = new function(){
 
    // this is declared as a private variable
    var secretBook = 'Book of Secrets';
 
    this.bearSon = function(){
        return {
            whatWasTheBookYourFatherTaughtYou: function(){
                alert(secretBook);
            }
        };
    };
};
 
// the father won't tell anyone about the book he has
alert(father.secretBook); // undefined
 
// the father bears a son
son = father.bearSon();
 
// the father dies
father = undefined;
 
// the son still knows the book his father taught him
son.whatWasTheBookYourFatherTaughtYou(); // Book of Secrets

secretBook was declared inside the father function and is a private variable, inaccessible to anything outside the father function. The father function closes around the variables declared inside of it. Anything defined inside the father function has access to it, even once the father function has executed and been undefined. The bearSon method returns a new object that contains a function called whatWasTheBookYourFatherTaughtYou.

http://code.google.com/apis/gdata/faq.html#clientlogin

What's a constructor function.

There's really no such thing as a constructor function. There are just functions, that's it, no different than any other function, except that you the programmer has made it so that it initializes a keyword called this with methods and properties. Here's the constructor function we will use for the rest of this post.

function Computer(manufacturer, model) {
  this.manufacturer = manufacturer;
  this.model = model;
}

What does new do?

The new operator creates new objects using our constructor function. Let's start by seeing what happens when we DON'T use the new operator.

var dell_inspiron = Computer('Dell', 'Inspiron');
alert(dell_inspiron); // undefined!

So what happened. Our Computer constructor function ran, it applied the manufacturer and model properties to the this keyword, which should have then populated our dell_inspiron variable. So what the hell was this pointing to? Let's see what's happening inside our constructor function:

function Computer(manufacturer, model) {
  alert(this);
  this.manufacturer = manufacturer;
  this.model = model;
}
var dell_inspiron = Computer('Dell', 'Inspiron');
alert(dell_inspiron); // undefined
// notice we now have two additional global objects manufacturer and model... not good
alert(manufacturer); // Dell
alert(model); // Inspiron

So as you can see calling a constructor function without using the new operator, causes our this keyword to point to the global object. Now let's try using our constructor function with the new operator.

var mac_book_pro = new Computer('Apple', 'Mac Book Pro');
alert(mac_book_pro); // [object OBJECT]
alert(mac_book_pro.manufacturer + ' ' + mac_book_pro.model); // Apple Mac Book Pro

This works as expected, and here's how. Using the new operator first creates a new blank object. Then, it invokes our constructor function, passing the newly created blank object as the this keyword. Your constructor function then populated the object pointed to by the this keyword with the manufacturer and model properties. When the constructor function ends, it automagically returns the object referenced by the this keyword to the mac_book_pro variable.

Additional Resources

Here's the example code in jsfiddle you can play with.

http://jsfiddle.net/bawigga/aQb5B/10/

If you want to read more about how the new operator works, I highly recommend the following books:

• Professional JavaScript for Web Developers (Wrox Programmer to Programmer)
  • Chapter 18 - Advanced Functions
• JavaScript: The Definitive Guide
  • Chapter 9 - Classes, Constructors, and Prototypes

Apache - httpd.conf - mpm_prefork_module Settings

<IfModule mpm_prefork_module>
    StartServers          2
    MinSpareServers       2
    MaxSpareServers       4
    MaxClients            50
    MaxRequestsPerChild   500
</IfModule>

I found that I saved a bunch of memory just by using less apache processes. Instead of spawing 8 processes by default I'm only going to spawn one and limit the max spares to 4, which means after some load I should only have 4 processes lingering around waiting to serve pages.

MySQL - my.cnf settings

skip-innodb
skip-bdb
skip-ndbcluster

I dropped mysql's memory useage by about 11M (sitting right under 5M right now) just by disabling innodb support. I've also done some very heavy WordPress caching using wp-supercache. this basically caches every page and post so that I'm just serving up static html content instead of processing the entire WordPress stack for every page load.

Programming

• Browsers
  • Safari - I use it for all my general development
  • Firefox - Mostly great for tuning CSS and pixel pushing
  • Google Chrome -  Great for debugging and performance testing
• Textmate - texteditor
  • open in Textmate - utility to put in your Finder that lets you quickly open files in Textmate
  • project plugin - better project handling for Textmate
• Versions - Very clean SVN client
• Fluid - great to take web pages you always access and make them their own app.
  • JIRA - This is just a great setup, this way JIRA is always a few keystrokes away
  • jQuery API - quick and easy access to the jQuery API
• iTerm - better replacement for the built in mac terminal
  • vim - best TE in the world (next to Textmate?)
• Sequel Pro - GUI for MySQL
• Charles Web Proxy - for intercepting and viewing http data, also great for testing slow connections to a certain domain
• Reggy - Regular expression sandbox, great for finding out what the hell is going on with a regular expression
• HTTP Client - Great app that let's you play with HTTP, great for testing out backend services
• VMWare Fusion - X-browser testing
• Adobe Photoshop CS5

Utilities

• Caffeine - awesome little app to keep your computer from going to sleep or launch the screensaver. You don't know how much you love caffeine until you actually use it a few times
• Divvy - awesome window management app that helps you resize windows on the fly using hotkeys or your mouse.
• Droplr - terrific app for taking screenshots and sharing them with others
• Spot Color - great little color picker
• VirtualHostX - app to manage all the virtualhosts installed on your system's apache instance
• iStat Menus - bunch of monitors that sit in your menubar and report system status to you. Great for keeping an eye on memory and processor usage

Misc

• Evernote - Great for taking notes throughout the day and also syncs back up with your iphone or mobile device
• Mail.app
• Pandorajam - If you listen to pandora, do your self a favor and download this badass app right now. Simply amazing.
• Grooveshark - think of iTunes, but has any song you can think of. Completely web based.
• Adium - IM client
• Colloquy - IRC client
• Echofon - Twitter client
• Skim - PDF Reader, much better than preview or acrobat reader