VMWare limits Fault Tolerance to a single core

In a recent post VMWare vs RedHat Virtualization I was pretty excited about using VMWare’s Fault Tolerance feature. This allows a VM to run on 2 separate servers with each command being executed in perfect sync across them. Should one fail, the other will pick up without losing a single instruction. It is important to note that non-deterministic events aren’t replicated. After looking very closely into the documentation, they sneak inside the requirements that the VM can only run on a SINGLE CORE. The screen shot listed is under “vSphere Availability Guide” What is even more interesting is the fact that the 8 page document “Protecting Mission-Critical Workloads with VMware Fault Tolerance” from VMWare fails to make a single reference to this limitation.

Hey you know what..many VM’s run just dandy with a single core. Let’s party like its 1999!

You heard that right.. If you run a critical application on 4 cores, 3 cores or even 2 cores, you are out of luck. Apparently they are working on multiple core support in the 12 to 18 month time frame.

Virtualization History

Although historical reference probably dates it later, my own roots in server Virtualization started about 6 or 7 years ago with XEN Server. Before that a server was just a server right? Each machine could only have a single operating system on it. There were Linux boxes and Windows boxes. If you started to outgrow the capacity of the server you simply upgraded the server. Some servers had too much CPU power and too little Hard Disk space, and others vice versa. A network administrator had to be very careful to gauge the requirements of the server to balance cost vs performance and still maintain some kind of semblance of ROI. Luckily over the next few years power increased dramatically as did our capacity and eventual need for more RAM and Disk space.

Virtualization describes a system in which there is a separation between the operating system and the hardware. Ok, some could argue such a separation has always existed in the form of BIOS, but this later is much much more.This layer is referred to as a Hypervisor. Most companies explain them as simply “stripped down operating systems” in that they are purpose built with a very small footprint. This is good in the sense that its easier for companies to maintain, and harder to hack. It acts as a safety net should one of the guest Operating Systems die, the whole machine isn’t taken down. It’s a layer that provides a common interface for other operating systems to co-exist on the same piece of hardware. This is significant in the sense that we no longer have a 1:1 correspondence between operating system and hardware. In an extreme case we could possibly add several gigs of ram and a few TB of Disk space to allow 10 or more operating systems to run on a single piece of hardware. The hardware processing power and memory could be used across these systems. In reality, the number of Operating Systems is only limited by the resources available. Buy a larger machine and have the ability to house more VM’s.

VMWare Overview

Whenever I think of Enterprise Server Virtualization I’ve always thought first of VMWare. Apparently I’m not the only one as 100 of the Fortune’s Top 100 are clients. In my professional experience, we started using VMWare Workstation to run Debian Linux machines on our Windows XP Pro machines. I can’t think of a single time where one of our Virtual Machine’s didn’t operate properly due to the VMWare. It certainly did have its own issues though. One of the top annoyances on my list would have to be the 100 hoops you had to go through to shrink your virtual disk. If you somehow managed to balloon your disk file to 20 gigs and were only using 1 gig, you had to go through many different steps to shrink it back. When taking snapshots and basing new machines from those snapshots the limits were a bit more pronounced as well. All said and done, it did the job and besides a chubby disk file, worked well.

In order to sit at the big kid table with VMWare, we have to be talking about the ESXi Hypervisor and vSphere. In broader terms lets describe a set of 2 machines with ESXi installed on the hardware. On top of that runs vSphere which does the real orchestration. Here is a list of some kick ass features that make their offering very promising.

1. vMotion – The ability to move a virtual machine from one physical server to another with NO downtime or interruption of service. In our 2 server configuration, let’s say we wanted to take Server #1 down for some kind of upgrade, but we had our production VM running Microsoft SQL Server 2005 with some load. This would allow us to say “Hey Mr. Machine..go wander over to that other piece of hardware” and lo and behold it would migrate across over to the new machine without interrupting a single SQL call. That’s pretty damn impressive.
2. High Availability – Simply put my little VM machine just took a big dump. The main server will detect this and will  restart it for me automatically.
3. Fault Tolerance – HA on crack. This will start a single virtual machine on 2 physical servers and lock them together event for event, instruction per instruction. In the event a single machine fails, the Doppelganger will automatically fail over without losing a single instruction.
4. Virtual CPUs – These are really processor Core’s per Virtual Machine. It does no good to move a physical machine with 4x4core processors to a Virtual Machine if it only has access to 2 cores. This is the maximum utilization for a VM. VMWare offers 4 SMP (Symetrical Multi-Processing) with all their lower offerings and up to 8 SMP for their highest “Enterprise Plus” offering.

Pricing for VMWare seems a bit high. They seem to split their offerings to target their high end offerings to big bad boy virtualizers, yet something that I think is rather new is their offering of “Acceleration Packs” which allow the smaller kiddies to get some more features if they’re small enough

RHEL Overview

Admittedly, I’ve never used RHEL. We’ve always run Debian for its well known stability in leau of its slow acceptance and verification process. It seems that RHEL tried to jump in to the virtualization market with its acquisition of KVM which powers its virtualization systems. Herein lies some of my issues with it. On one hand, they tout virtualization comes “standard” with RHEL..meant to imply you don’t pay extra for it (cough).

1. vMotion – Yup, got it..similar to vMotion of VMWare
2. Virtual CPUs – To my surprise they actually support 2x the virtual processors (cores) per VM over what VMWare offers in their highest offering. That is a total of 16 vCPUS.
3. Pricing is much much cheaper then VMWare.

Things start to get a little shaky though when you start going beyond that. For one..and yes..just pause for effect here..you aren’t reading this wrong.. At the time of this writing the web interface to manage the virtualization MUST be run on Windows Server 2003. That’s right.. Your Linux powered environment is being managed through a Windows machine.. The site mentions a pure Linux management interface is “in the works”.. Holy @#$# people.. talk about getting the cart in front of the horses. For me this was kind of a deal breaker. With vMotion support, VMWare even allows the management console to be running INSIDE a virtual machine. I know..that really does break the laws of space time.

Google Mini Features

We went with the highest available Google Mini Appliance that can index 300,000 pages for a retail price of ~$10,000 US. The website doesn’t show too much about the actual physical hardware besides pointing out this 10k gem has NO RAID support. For those companies that need mission critical availability, but can’t fork over the min amount to get into the real Google Appliance offering they suggest buying 2 Google minis. Uhm what? Ok so I dropped 10k on this server and you can’t throw in a $150 raid card and another hard drive. That’s just annoying.

Auto Spell Checking / Suggestions

The appliance has some kind of black magic spell check thing going on which isn’t too horribly helpful. There seems to be no way to add onto the dictionary which is pretty annoying. Even more annoying is the fact that even if you supply synonyms for words, it WILL NOT give you the spelling suggestion every time. In my testing I had to perform the exact same search with my misspelling 4-5 times before it gave me the synonym suggestion. As quoted from Google

“The Google Mini uses sophisticated algorithms to generate spelling suggestions from the content in your index. It is especially good at providing relevant spelling suggestions for proper nouns such as the names of employees and product names. The spelling system is fully automated; so it is not possible to manually edit the spelling dictionary. “

Query Expansion / Keyword Stemming

This is kind of a bummer. The Mini doesn’t support this feature. Ideally as an admin I should be able to say “Hey Mr. appliance, I want you to consider these 3 words as equals”. There are many cases where I want to server relevant search results based on a small set of keywords instead of having the results scattered across multiple keywords. For instance, what I had a ton of content that related to “Tonnea Covers” “Truck Bed Covers” or “Tonno Covers”. All 3 are the exact same thing, yet its possible if the visitor searches for one, they won’t get the content behind the others. Of course there are ways “around” this, but ideally I should be able to tell the appliance these terms are the same and interchangeable.

Synonyms

This is a way for us to suggest another term to search for based on a keyword in the original search. This is *kind* of a work around the Keyword Stemming issue, but the jist is that you’re still forcing the visitor to click around to see the other search results instead of serving them up all in one group the first time.

Meta Data Fetching / Searching

This is actually a pretty sweet feature. We can expose Meta Data on our pages and filter our search results by them, and also fetch the full meta data itself. This would allow us to cache data right on the appliance for us to pull through on the presentation side instead of being force to do lookups on presentation per data row.

Integration Options for the Google Mini

There’s basically 2 different mechanisms that we can use to integrate with the beast.

Fully Formatted Search Output From the Appliance

XML Search Output

Issues / Bugs with the Google Mini Search Appliance

Broken Preview Feature and Images.

Ok its probably not a good sign when the first thing you see when you log into the appliance after setup are a bunch of broken images. It wasn’t a huge deal..but after dropping 10 large on a machine I would hope for more. There is also a preview sections that allows you to modify the XSL stylesheet and see it before saving, that was just simply broken.

Temporary server error. Try again in a minute.

Just over a month out of the box, we started having issues. We’re indexing only a fraction of our max page limit and I would summarize our overall search load as “low”. We started getting the following ominous error “Temporary server error. Try again in a minute.” The mini comes with tech support now automatically, so it was time to get them in the loop to see what the deal was. Now if you’re one of those shops that didn’t pay for the super-uber tech support get ready to wait. Support was only via email and took about a day per email to work through things. All said and done the tech though we were experiencing a documented “Issue” and recommended we update our OS software and server software to the latest versions. Now here’s where things start to get fun. There are 2 different types of updates to view. One is for the Linux OS they have running and another for the actual search engine software running on it. As it turns out, the mini stopped spitting this out and we just decided to address it later should it arise again. Little did we know what was in store!

Google Mini Appliance Crash / Dead In the Water

About a month after the issue above, we had a hard crash. The appliance was horribly slow on the admin side and only 10% or less of the search requests were actually getting fulfilled. Those that WERE getting fulfilled were very slow (10-45 seconds each). After a full reboot, it was fine..for 1 minute..then started the same crap. At this point we decided to  push forward with our full OS/Server software updates. That took about 2 hours all said and done and all issues were finally resolved after that.
coming from the XML output from the box.

In order to get Bridged Mode working on the Virtual Machine, the adapter it connects to must support promiscuous mode. It was connecting to my Wireless adapter..just like it was in the previous computer. You think it supported it? yeah..bad times. I simply told VM to use the normal Lan adapter, connected it to the wireless switch and kablam, i had my IP..Nice 5 hours of wasted time. I hope this helps someone cause it took me forever to figure out

Peanut Butter and Jelly

mmmmm. Holy crap I love PB&J sandwiches. In fact I just got done eating one. That reminded me of a really fun and silly activity I did when I was an On The Road Trainer for Chilis Bar & Grill. Mind you that was a LONG time ago.

The Activity

Ok the jist is very simple. The process involves 2 people. One person who is going to be trained (Instructor) in the method and the trainer (Sandwich Builder). The goal is to get the Builder to put together the sandwich with the directions being supplied by the Instructor. Now this sounds pretty easy doesn’t it? The fun part is to take what the Instructor says for face value and only do the bare minimum to comply with the direction. Here is a fun example:

Instructor: Pick up the bread.
Builder: Uses his feet to pick up the piece of bread.
Instructor: No, pick up the bread with your hands.
Builder: Uses the back of his hands to pick up the entire loaf of bread.
Instructor: NO! Pick up a single slice of bread.
Builder: Uses his mouth to pick up a slice of bread still in the wrapper.
Instructor: GAAH No, Use your hands to take the slice of bread out of the wrapper.
Builder: Uses the bottoms of his hands to pick up the piece of bread then eats it.

You can see how quickly this can become horribly out of control. Its a lot of fun. Here is something that would get the Builder to do the job correctly.

Instructor:
Using your right arm slowly extend your arm so that your hand is approximately 3 inches from the mouth of the loaf of bread.
With your right hand make a pinching gesture using your pointer finger and thumb.
Open this gesture the thickness of the first piece of bread in the loaf.
With great care move your arm and hand toward the first slice of bread as such the first slice is inserted in the the space between your pointer finger and thumb; The orientation of the hand will be perpendicular to longest side of the bread so that the piece will fit into the gesture without compression or deformation.

You can easily notice the great level of detail between the 2 examples. Each time I communicate I try to nail down the appropriate level of detail for the audience in order to make certain they are on the same page as I am so we don’t have to double back to clarify things that should of been clear from the beginning.

About Javascript Context

If you’re a stickler for Javascript class encapsulation, when you get into Ajax calls, things start to get pretty hairy. You will quickly find out that if you want to fire a method of your Javascript class instance, it WILL call it…oh yes…it will…but will lose all context as to where it belongs. For instance, if we have a method that purely local variables, all will be fine and dandy. It has local scope or utilizes global Javascript variables so all will perform as you expect. Its only when you start accessing this. values when things go ape-shit. The best way I can image it myself is to think that Javascript is grabbing a copy of my routine and placing it into nana land and at that point this.anything is meaningless. this is no longer the THIS that you mean it to be when you first assigned the function.

Be A Lazy Ass And Store The Calling Context In A Global Variable

You will notice in the code that it forces you to pass in the context of the function that you are going to be firing in response to the Ajax request. I personally think this is a good thing to enforce. It makes you always think about what context your functions are going to be called and with member functions being fired by events, this is a good thing to keep in mind. By default the code will store the global context as this, which is the small utility class to fire off an Ajax request. This will make sure then when our local member function is called OUT of context, that we can access a known global variable to hop back into the correct context which would be this EXACT instance of the class. Realize that 2 concurrent requests will blow this out of the water. The class is designed for a quick and dirty one shot deal, nothing more. If we want to get any fancier, we will need something to help us keep track of all this crap.

Use A Globally Instantiated Context Handler For Your Page Lifetime

I just love thinking about this because I mean, cummon, it sounds pretty big and important right? Well in reality its a fancy description for a single Javascript class who’s only mission in life is to keep track of all our Ajax requests. Instead of relying on a single global variable to hold our THIS context, we will instead get passed in an instance of the Global Context Handler. Then when we get a response on from our Ajax request, we simply tell our handler to go check its children to see who fired. At that point, the Context Handler will loop through all its instances of our class and when it finds one that has fired and hasn’t been handled, it will call the handling function for THAT specific instance which will make sure we maintain the correct Javascript Context. As you see in the code below, its horribly stupid, but really does the job.

Another thing to consider is that we could also have this Marshalling our Ajax requests as well. I’ve read that many browsers can only handle a few Ajax requests at the same time. The Context Handler class would be the perfect spot to push all our requests on a queue and when we call CheckEvents and get a new event handled, we can nuke that Ajax request and start a new one from our queue.

/**
 * 
 * @param {String} HttpUrl - The Url to post to
 * @param {Object} CallBackContext - The object which contains the CallBackFunction
 * @param {Method} CallBackFunction - The call back function
 * @param {String} PostMethod - The get/post method
 * @param {String} Parameters - Parameters to pass in the get/post string
 * @param {Object} ContextHandler - This is an instance of our  global context handler. That allows concurrent
 * ajax calls correctly.
 */
function Ajaxv2(HttpUrl,CallBackContext,CallBackFunction,PostMethod,Parameters,ContextHandler)
{	
	this.HttpUrl		= HttpUrl;
	this.PostMethod		= PostMethod;
	this.Parameters		= Parameters;
	this.ContextHandler	= ContextHandler;
	this.Handled		= false;	
	this.Version		= 2.0;
	this.Request		= null;
	this.EventData		= null;
	
	GlobalAjaxv2Context	= this; //really only for single fired events, 2 concurrent wont' work without a  context handler.
	
	if(typeof(ContextHandler) == "undefined")
		this.ContextHandler=null

	//this checks our state and performs the callback function on success
	this.GlobalProcessRequestAjaxv2 = function()
	{		
		
		//when this even fires, our context is WITHIN the XMLHttpRequest object itself
		if(typeof(ContextHandler) != "undefined")
		{
			/*
			 * DO NOT fire our event off our globallly stored context. we are using a Context Handler meaning we are firing 2+ events at once. We need
			 * to let the context handler do its thing.
			*/
			ContextHandler.CheckEvents();
		}			
		else
			GlobalAjaxv2Context.ProcessRequestAjaxv2();
	}
	this.ProcessRequestAjaxv2 = function()
     {	
	 	try
		{
			if(this.Request.readyState == 4) 
			{
				//According to the HTTP 1.1 specification, any response that has a code between 200 and 299 inclusive is a successful response.
				if(this.Request.status >= 200 && this.Request.status <= 299) 
				{
					CallBackFunction.call(CallBackContext,true,this.Request,this.EventData);					
				} 
				else 
				{
					//error out with the server error code and message.
					CallBackFunction.call(CallBackContext,false,this.Request,this.EventData);
				}
			}
		}
		catch(exception)
		{
			alert("An exception was caught while trying to process an AJAX request. ("+exception+")");
		}		        	
     }	
					
	//this creates our object
     this.InitAjaxv2 = function()
     {	     
	     try 
	     {
	     	HttpRequest = new XMLHttpRequest();
	     } 
	     catch(e) 
	     {
	     	try 
	       	{
	       		HttpRequest = new ActiveXObject("Msxml2.XMLHTTP");
	       	} 
	       	catch (e) 
	       	{
	        	try 
	        	{
	         		HttpRequest = new ActiveXObject("Microsoft.XMLHTTP");
	         	} 
	         	catch (E) 
	         	{
	          		HttpRequest = null;
	         	}
	       	}
	     }	     
	     return HttpRequest;
	 }
	

	//this actually sends the get or post request
	this.GetPost = function(Async)
	{
		this.Request = this.InitAjaxv2();

		if(this.Request == null)
			return false;
			
		this.Request.onreadystatechange=this.GlobalProcessRequestAjaxv2;
		
		//setup our context handler if we need to
		if(this.ContextHandler != null)
			this.ContextHandler.AddAjaxv2Object(this);
	
      	this.Request.open(this.PostMethod, this.HttpUrl, Async);
	    this.Request.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset=UTF-8");
	    this.Request.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT");
      	this.Request.send(this.Parameters);
      	
      	/*
      		MOZ browser will never fire onreadystatechange when in synchronous mode,
      		but they will wait for req.send to complete. So we can fire the function here instead.
      		http://www.quirksmode.org/blog/archives/2005/09/xmlhttp_notes_r_2.html
      	*/
      	if (Async == false)      	
      	{
			this.GlobalProcessRequestAjaxv2();   	
      	}		
	}
	
	/*
	*   @name getFormValues()
	*   @descr This function creates a string of the name-value pairs for the specified form object
	*   @param (object) fobj - the form object that the values are wanted for
	*   @return str - the string containing the name-value pairs for the form object
	*/
	this.GetFormValues = function(fobj)
	{
	    var str = "";
	    var valueArr = null;
	    var val = "";
	    var cmd = "";
		var obj;
	
		//get all the inputs
		var objects = fobj.getElementsByTagName('input');
		for(object in objects)
		{
			obj = objects[object];
			switch(obj.type)
			{
				case "text":				
				case "hidden":
					str += obj.id + "=" + escape(obj.value) + "&";				
					break;
					
				case "radio":
				case "checkbox": 
	                if  (obj.checked)
	                    str += obj.id + "=" + escape(obj.value) + "&";	                
	                break;
	            
			}
			
		}
		
		objects = fobj.getElementsByTagName('select');
		for(object in objects)
		{
			obj = objects[object];
			switch(obj.type)
			{
				case "select-one":
	                str += obj.id + "=" + obj.options[obj.selectedIndex].value + "&";
	                break;	            
	            
	            case "select-multiple":
	            	for(f=0;f

/**
 * Global Ajax Context Handler. This is simply a global class that keeps track of all ajax requests we've made and when told to, will loop through them to see if there are
 * any that need to be taken care of. By housing all instances in a single spot, we  can simply tell this  class to CheckEvents and it will loop through its internal
 * array of ajax objects to see which objects have have completed, yet haven't been handled. This way it doesn't care who actually STARTED this request, it will always
 * fire the right handler for the right ajax object.
 */
function AjaxContextHandler()
{
	this.AjaxObjects = Array();
	
	this.AddAjaxv2Object = function(object)
	{
		this.AjaxObjects.push(object);		
	}
	
	
	this.CheckEvents = function()
	{			
		for(var i=0;i

I was having an interesting conversation with some buddies the other day about the current status and future direction of open source projects. It really seems that the software industry is flooded with LAMP or RAILS open source projects and rarely .Net. From one of my C#/.Net developer buddies came the question:

Why do you think people gravitate towards more open source / LAMP packages for online content distribution?

It took me a while to really get a good perspective on this and I think I can offer a few bits of incite. I should mention I consider these not to be ultra enlightening objectifications.

Maturity

With the whole Blog “phenomena” going crazy the past few years we’re talking about more and more ordinary people wanting to etch out their little corner of the net. These people aren’t willing to shell out money for blog software. The whole Blog push was actually being *driven* by open source software from the start. It was only until it really started to become popular that other companies like Movable Type started joining in on the fun to make some money. With Blog software being founded on free technologies, this ultimately meant that there were many more available developers to contribute to making the software better since there was literally no cost to contribute. The same can’t be said for .Net development.

Target Users

.NET development shops are all about money. That’s just the nature of the beast. Its really hard to spend the serious cash involved in getting a development environment setup and a product created without wanting to recoup some of those thousands of dollars shit to the wind to the MS beast. This can really be a good thing. Off the shelf components all come with a price tag and while this really sucks for the little guy, the corporations that utilize said goodies have at least SOMETHING to hang onto for leverage when it comes to support for the product.

Wow that’s a huge title LOL. Well in reality I think you’ll find the subject matter pretty straight forward.

The issue

The issue is how to move to a more object oriented presentation layer and still be able to have an object that self sufficient without having to manually include a but load of CSS or JS files on the final web page. What’s the point in having a high resolution of presentation layer abstraction if you have to instantiate the object on the page and also figure out what it uses and include those files?

The answer

I know for a fact I read the whole list on what was new with PHP5 but apparently I didn’t put 2+2 together for quite some time doh! You see, ideally we would have a magic array or list or “magic white board” that our instantiated presentation layer objects would all use to keep track of what their dependencies were so when it came time to render our page we not only didn’t need to hard code the references, but we didn’t need to go hunting around for what those references were either. That allows us to keep a very nice “pure” abstraction for our objects. Each object is a cute little guy with a css to encapsulate its presentation, and the actual php file to encapsulate the presentation logic.

Rough Justonian Code

Ok, so the jist of this methodology is to have a magic Presentation Layer Base Class that we can derive from and that allows us to push our dependencies onto an array where we trust that our calling page to use our base class static method to print out ALL our dependencies. I don’t mean just for one object, but one call for all instantiated Presentation Layer Objects that derive from this base. So, something like:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66.

<? class PresentationObjectBase {     /** Constant to represent CSS Dependencies */     const DEPENDENCY_CSS        = 1;     /** Constant to represent Javascript Dependencies */     const DEPENDENCY_JAVASCRIPT = 2;     /** Our static base class array that will hold the dependencies for ALL presentation objects */     static private $_dependencies=array(); # we need to initialize in case we check for a dep, but have none.     /**     * Adds a dependency to the internal list     *     * This routine will add a dependency to the internal list under the selected type. The base class holds     * ALL dependencies     * for ALL presentation layer objects.     * @param int $dependency_type One of the DEPENDENCY_ constants.     * @param string $full_tag The full tag to be printed to the browser come rendering time.     */     protected static function add_dependency($dependency_type,$full_tag)     {         self::$_dependencies[$dependency_type][] = $full_tag;     }     /**     * Gets a dependency from the internal list     *     * This will return an array of registered dependencies for the type specified.     * for ALL presentation layer objects.     * @param int $dependency_type One of the DEPENDENCY_ constants.     */     protected static function get_dependency($dependency_type)     {         if(array_key_exists($dependency_type,self::$_dependencies))             return self::$_dependencies[$dependency_type];         return false;     }     /**     * Prints a dependency from the internal list     *     * This will print the array of registered dependencies selected by type, split by newlines.     * @param int $dependency_type One of the DEPENDENCY_ constants.     */     public static function print_dependency($dependency_type)     {         $depend=self::get_dependency($dependency_type);         if($depend !== false)         {             print join(array_unique(self::$_dependencies[$dependency_type]),"\n");             return true;         }         return false;     }     /* Use Example     in the derived class     parent::add_dependency(self::DEPENDENCY_JAVASCRIPT,"<script type='text/javascript' src='/js/my_js_file.js'></script>");     and in the main php page that does the rendering     <?php PresentationObjectBase::print_dependency(PresentationObjectBase::DEPENDENCY_JAVASCRIPT); ?>     <?php PresentationObjectBase::print_dependency(PresentationObjectBase::DEPENDENCY_CSS); ?>     */ } ?>

The somewhat crappy limitation here is that you have to instantiate your presentation layer objects before actually outputting the head portion of your code if you want the css includes to work properly. Thus far for me that really isn’t a deal breaker.

Ok I think this makes it official. I’ve seen the following issue on 2 boxes. The system works properly with PHP5.2.1 and the Debian Stable release of FreeTDS. When moving to PHP5.2.2 I was suddenly getting really odd Date errors. Loading objects from the database and pushing the values back to MSSQL would result in an invalid date format. Upon further inspection, I saw that the date was being pushed as “Sun Jun 4 10:34:23 2007″. Notice how the year is on the end instead of right after Jun 4. Very very odd.

The easy fix was to nab the latest version of FreeTDS .64 at the time of this posting, recompile PHP against it and install. Pretty crappy..