Zend Framework applications are quite easy as all request are forwarded to index.php handling all request, so all global settings like include_paths can be handled there. However, with some PHP websites it is quite hard to introduce a common global PHP include file for application that has no single PHP file the application starts with, and it depends on a include_path set with php_value. The solution is to use Apache mod_rewrite to redirect all php request to a single file, proxy.php, that sets the global settings, and runs the original PHP file requested.

Add the following mod_rewrite code to your Apache vhost file or in .htaccess in the document root:

RewriteCond %{REQUEST_FILENAME} ^(.*)\.php$
RewriteCond %{REQUEST_FILENAME} -f
RewriteRule ^(.+)$ proxy.php?proxy_script=$1 [QSA]

This will cause all request ending with .php to be redirected to /proxy.php?proxy_script=original_file.php
In the proxy.php file we define following code to set the global settings and handle the original request:

/* Declare global PHP stuff */

set_include_path(get_include_path() . PATH_SEPARATOR .
   '/home/www/mysite/current/include' . PATH_SEPARATOR .
   '/home/www/mysite/current/localsettings'
   );

//register globals ( EVILNESS!! 'm' )
foreach($_REQUEST as $varname => $varvalue)
        $$varname = $varvalue;

/****************************/

$proxy_script = str_replace('..', '.', $_REQUEST['proxy_script']);

$script = $_SERVER['DOCUMENT_ROOT'] . '/' . $proxy_script;

if (is_readable($script) && $proxy_script != 'proxy.php') {

   // set environment for the original request
   $_SERVER['SCRIPT_FILENAME'] = $script;
   $_SERVER['PHP_SELF'] = $_SERVER['SCRIPT_NAME'] = '/' . $proxy_script;

   // run original request
   include($script);

} else {
   header("HTTP/1.1 404 Not Found");
   print "<h2>404 not found</h2>";
}

Now every request will be handled properly, while global environment can be set easily in the proxy.php file.

$date = new Zend_Date(...);
....
print $date->toString();

The toString() method takes up lots of execution time. To ‘fix’ that, instead of this we use a cache object that has the original object and forwards all calls from the cache object to the original object, and caches the output, so next time, it will be served from cache.

$date = new Zend_Date(...);
....
$cachedDate = new Cache($date);
print $cachedDate->toString();

Preserve object type

Sometimes you want to use type hinting and other methods to force the right type of object to be used within your application. Therefore you can use interfaces so both the cache object and the date object roots from the same interface which describes the proper abilities:

interface Interface_Date { public function toString(); }

class Date extends Zend_Date implements Interface_Date {}

class Cache_Date extends Cache implements Interface_Date
{
	public function toString()
	{
		return parent::__call('toString', array());
	}
}

function printDate(Interface_Date $date) { print $date->toString(); }

$date = new Date(...);
....
$cachedDate = new Cache($date);
// both work now using type hinting:
printDate($date);
printDate($cachedDate);

Iterators

The cache object is most usefull when using and looping through long lists of objects. Therefore a Cache_Iterator becomes handy. For maximum execution efficiency, it will keep all calls to all containing objects in one cache item and writes it to cache on destruction of the Cache_Iterator container object.

/* for example */
$dates = $users->getBirthDates();
/* assume $dates is an iterator with slow Date objects in it */

$datesCached = Cache_Iterator($dates);

foreach($datesCached as $dateCached)
{
	// dateCached is now a Cache object proxying a Date object
	print $dateCached->toString();
}

Also here, type preserving can be done.

/* extend Cache_Iterator and make it
   producing Cache_Date objects instead
   of Date objects when looping */
class Cache_Iterator_Date extends Cache_Iterator
	{ protected $_class = "Cache_Date"; }

$dates = $users->getBirthDates();

$datesCached = Cache_Iterator_Date($dates);

foreach($datesCached as $dateCached)
{
	// dateCached is now a Cache_Date object
	printDate($dateCached);
}

Cache ID auto generated

The cache ID is generated by a md5 sum of a serialized object. The serialisation does not take significant execution time and it will make sure that an updated object or iterator with objects will generate new cache instead of showing the old contents. It however also means this won’t be usefull if the object or object iterator changes all the time. In such cases, find another unique ID like the combination of get_class($object) and $object->count() (Iterator), or $object->id (single object).

When does this cache method not help

When the time consuming or load is not caused by object code execution, but for example, (inefficient) database queries, database overload or a problem before or after or somewhere else but showing contents of the object. (No shit…) You should analize time consumption in your (too slow) application quite carefully. It’s however quite easy, by using print microtime(); between your statements.

The classes

The code can be downloaded at http://www.welmers.net/~bastiaan/php-cache.tar.gz

/**
 * @author Bastiaan Welmers
 *
 * cache layer to an object
 */
class Cache
{
	/**
	 * holds object that needs to be cached
	 * @var object
	 */
	private $object;

	/**
	 * the Cache ID of the cache data in Zend_Cache
	 * @var string
	 */
	private $cacheId;

	/**
	 * The instance of Zend_Cache
	 * @var Zend_Cache
	 */
	private $cacheInstance;

	/**
	 * The cache data
	 * @var array
	 */
	private $cache;

	/**
	 * Keeps track of changes in cache data. If true, cache data needs to be saved on destruction
	 * @var boolean
	 */
	private $needSave = false;

	/**
	 * Set to false by constructor if data doesnt need to be saved on destruction. default true.
	 * @var boolean
	 */
	private $saveAtDestruct = true;

	/**
	 * construct cache object.
	 * @param object Object that needs to be cached
	 * @param object optional object (passed by instance) where to save data in, instead of
	 *               creating our own. if this variable is set, cache data wil not be saved by us
	 *               @see Cache_Iterator for this kind of use
	 */
	public function __construct($object, &$cache = false)
	{
		$this->object = $object;
		if ($cache === false)
		{
			// cache variable passed, here we save the data in.

			// try to find an unique id of the object for saving
			if (isset($object->id))
				$this->cacheId = get_class($object) . $object->id;
			else
				$this->cacheId = get_class($object) . '_' . md5(serialize($object));

			// get cache instance from zend_registry. Here we use a Zend_Cache backend object.
			// Here you can set your own if not using Zend_Cache.
			// It must however implement save() and load().
			$this->cacheInstance = Zend_Registry::get('cache');

			// load data from cache if available
			$this->cache = $this->cacheInstance->load($this->cacheId);
			if (!is_array($this->cache))
				$this->cache = array();

		} else {
			// cache variable passed, here we save the data in.
			$this->cache =& $cache;
			if (!is_array($this->cache))
				$this->cache = array();
			// don't save the data on destruction
			$this->saveAtDestruct = false;
		}
	}

	/**
	 * catch all calls to this object and transparently pass them
	 * to the object with caching in between.
	 * @param string method name
	 * @param array arguments of functions
	 * @return mixed result of call
	 */
	public function __call($method, array $args)
	{
		if (is_callable(array($this->object, $method)))
		{
			// make up an string ID
			$id = "method_{$method}_" . md5(serialize($args));
			if (!isset($this->cache[$id]))
			{ // not found in cache, do the actual call to our object

				$return = call_user_func_array(array($this->object, $method), $args);

				// if having a Date object, return a dedicated date cache object
				if ($return instanceof Date)
					$return = new Cache_Date($return, $this->cache[$id . '_date']);

				// save our result in cache data array
				$this->cache[$id] = $return;
				// we need so save the cache at destruction
				$this->needSave = true;
			} else
				// found in cache, get data from cache
				$return = $this->cache[$id];

			return $return;

		} else
			throw new Cache_Exception(get_class($this->object) . "::$method() is not callable");
	}

	/**
	 * catch all properties of this object and transparently get them
	 * from the object with caching in between.
	 * @param string property
	 * @return mixed result of underlaying object
	 */
	public function __get($property)
	{
		if (isset($this->object->$property))
		{
			$id = "property_{$property}";
			if (!isset($this->cache[$id]))
			{ // not found in cache. request from our object
				$return = $this->object->$property;
				// save in cache data array
				$this->cache[$id] = $return;
				// we need so save the cache at destruction
				$this->needSave = true;
			} else
				// get our result from cache
				$return = $this->cache[$id];

			return $return;

		} else
			throw new Cache_Exception(get_class($this->object) . "::$name is not set");
	}

	/**
	 * Checks if an item is set. We pass it to the
	 * the object directly.
	 * @param string property
	 * @return boolean true if set false if not
	 */
	public function __isset($property)
	{
		return isset($this->object->$property);
	}

	/**
	 * destructor for saving cache data to cache if neccessary, on
	 * end of object lifetime.
	 */
	public function __destruct()
	{

		if ($this->saveAtDestruct && $this->needSave && isset($this->cacheInstance))
			$this->cacheInstance->save($this->cache, $this->cacheId);

	}

	/**
	 * __toString magic function if this object is used as string.
	 * pass call to __call()
	 */
	public function __toString()
	{
		return $this->__call('__toString', array());
	}

}

/**
 * @author Bastiaan Welmers
 *
 * cache layer to an iterator
 * @see Cache
 * @see Iterator
 */
class Cache_Iterator implements Iterator, Countable
{
	/**
	 * Cache object to be spawned by current()
	 * @var string
	 */
	protected $_class = 'Cache';

	/**
	 * holds Iterator object that needs to be cached
	 * @var Iterator
	 */
	private $object;

	/**
	 * The instance of Zend_Cache
	 * @var Zend_Cache
	 */
	private $cacheInstance;

	/**
	 * The cache data
	 * @var array
	 */
	private $cache;

	/**
	 * the Cache ID of the cache data in Zend_Cache
	 * @var string
	 */
	private $cacheId;

	/**
	 * construct cache object.
	 * @param Iterator Object that needs to be cached
	 */
	public function __construct(Iterator $object)
	{

		$this->object = $object;
		$this->cacheInstance = Zend_Registry::get('cache');
		$this->cacheId = get_class($object) . md5(serialize($object));
		$this->cache = $this->cacheInstance->load($this->cacheId);
		if (!is_array($this->cache))
			$this->cache = array();
	}

	/**
	 * Rewinds object.
	 * Passed directly.
	 */
	public function rewind()
	{
		$this->object->rewind();
	}

	/**
	 * Get current value, and cache it if it is an object
	 * @return mixed value
	 */
	public function current()
	{
		// get value
		$object = $this->object->current();
		if (is_object($object))
			// create cache layer object of object,
			// pass our cache data array to it so it can save
			// its data there
			$object = new $this->_class($object, $this->cache[$this->key()]);

		return $object;
	}

	/**
	 * Get key of current value
	 * Passed directly.
	 * @return int key
	 */
	public function key()
	{
		return $this->object->key();
	}

	/**
	 * Move to next value.
	 * Passed directly.
	 */
	public function next()
	{
		$this->object->next();
	}

	/**
	 * Is current object still valid?
	 * Passed directly.
	 * @return boolean valid or not
	 */
	public function valid()
	{
		return $this->object->valid();
	}

	/**
	 * For countable iterators, count the values
	 * Passed directly.
	 * @see Countable
	 * @return int amount of values
	 */
	public function count()
	{
		if ($this->object instanceof Countable)
			return $this->object->count();
		else
			throw new Cache_Exception('Object of class ' . get_class($object) . ' does not implement Countable');
	}

	/**
	 * Destructor which saves the cache data at the end of object life time
	 */
	public function __destruct()
	{
		$this->cacheInstance->save($this->cache, $this->cacheId);
	}

}

Probably this is just the openesuse 11.1 repository, but I’m not sure, it could also be a prerelease of
11.2. If the repositories disappear, I hve placed the files on
http://www.welmers.net/~bastiaan/kdevelop3-opensuse11.2/

Items like qt3, cvs, subversion, ruby, python, kdebase3, kdelibs3, kdelibs3-devel should be installed
from the OpenSUSE 11.2 repository. After that, these additional packages are neccessary:

kdebase3-devel-3.5.10
kdebindings3-3.5.10
kdebindings3-ruby
kdesdk3-3.5.10
python-kde3-3.16
python-qt-3.17
and at last:
kdevelop3-3.5.3

Probably the binary package from kdevelop.org can be used too, but I didn’t try that yet.

De vraag is natuurlijk hoe dit werkend te krijgen onder Linux. Er zou een programma bij zitten die gebruikt kon worden, maar die heb ik niet gevonden tot nog toe. Met pppd en de KDE gui kppp werkt het echter ook prima.

De bijgeleverde modem is de Huawei E176. Een aardige HSPA/UMTS modem met micro-sd card slot en externe antenneaansluiting.

Wanneer de stick in een linux computer geplugd wordt (opensuse 11.1 kernel, 2.6.27) dan verschijnt er een /dev/ttyUSB0 aparaat. Deze kan gebruikt worden als normale modem om verbinding te leggen.

Met kppp kan uiterst eenvoudig de modem gebruikt worden. Het volgende dient te worden ingesteld:

- te kiezen nummer: *99***1#

- te kiezen modemaparaat: /dev/ttyUSB0

- Kies als login/wachtwoord: web en web

Voordat je het modem kan gebruiken, moet je op het modem identificeren met de PIN code. Dit kan met het modemcommando AT+CPIN=pincode. In kppp kan via Instellen->Modems->Wijzigen->Modem->Terminal een terminal geopend worden.

Voer hier het commando in, de modem zal OK retourneren bij de juiste pincode en het modem zal contact maken met een netwerk en het lampje zal blauw gaan knipperen.

Vervolgens kan er verbinding gemaakt worden:

Na het ATDT dial commando zal een CONNECT verschijnen, of NO CARIER als er geen netwerkbereik is.

Met kppp is vervolgens te zien dat er verbonden is en er is een grafiek en een lijstje met gebruikte data. Handig om een beetje in de gaten te houden dat je niet te snel te veel gebruikt.

Na het verbinden verschijnt er een ppp0 interface die met /sbin/ifconfig gezien kan worden met het IP dat je krijgt van T-Mobile. Tevens verschijnt er een default route, die naar 10.64.64.64 komt te staan. Ik kwam er achter dat /etc/resolv.conf niet wordt geupdate en dat er dus geen DNS servers bereikbaar zijn. Er staat echter een resolv.conf in /var/run/ppp_resolv.conf.ppp0 die met cp naar /etc/resolv.conf gekopieerd kan worden. Dan is de verbinding klaar voor gebruik.

TODO:
- Het AT+CPIN commando automatiseren
- Manieren vinden om meer met het modem te kunnen zoals sms versturen, statestieken op te vragen, beschikbare netwerken te bekijken en te kiezen…

Direct op mijn Quest gemonteerd en een trainingsrondje Soesterberg-Austerlitz gereden en een retourtje Utrecht-Enschede (286km).

Dit vooral om de band in te rijden en eens te kijken of de band een beetje snel is. Resultaat: de band is vrij snel maar een groot verschil met de Swalbe Kojak 50-559 (standaard achterband Quest) is niet echt voelbaar, behalve dat de band op 9 bar sneller dribbelt en oncomfortabeler loopt op klinkers.

Het doel zou zijn voor wedstrijden met de Quest op asfalt bij snelheden waarbij een dikke zware achterband mogelijk te veel luchtweerstand heeft en zwaarder accelereert. Bovendien zou de dunne Conti bij 9 bar toch lichter kunnen rollen dan een Swalbe Kojak 50-559 bij 5,5 bar (de max druk). Ik zou hiervoor eens rolweerstandtesten willen uitvoeren (wie weet een goede lokatie? verhoging van enkele meters en een perfect egaal uitrolparcours van middelmatig grof asfalt).

Andere mogelijke kandidaat voor gebruik is bij mijn Xlow achterwiel.

Vandaag heb ik de GatorSkin vervangen door een 25-559 Grand-Prix voor een trainingsrondje van 42km en ik vermoed dat de Grand-Prix toch lichter loopt dan de GatorSkin.

Oude Conti GrandPrix banden 559 en 406

Verder heb ik ook een 2tal nieuwe Continental Grand-Prix banden gekocht. De nieuwe Grand-Prix banden zijn anders dan de oude. Voor het gevoel zachter rubber, andere wangen, en iets breder, en nog steeds behoorlijk soepel, misschien zelfs soepeler. Maximale aangegeven druk is verlaagd van 8,5 naar 8 bar. (in praktijk is 9 bar prima). Deze ga ik binnenkort monteren op de voorwielen van de Quest om te kijken hoe ze lopen. Ook een rolweerstandproef zou ik graag willen uitvoeren, tezamen met de nieuwe 406 racebanden van Swalbe, de Durano.

Nieuw Conti GrandPrix 406 en GatorSkin 559

Met een vaartje van 37km/h rijd ik tegen de wind in. Het is opmerkelijk hoe het tegenvalt als je in het onderste stuk van de dijk nog een hele slinger naar buiten moet maken, terwijl je maar 1km van het vaste land bent waar je zijn moet. De brug bij de sluis gaat net open, en een hele rits 3masters gleed langzaam voorbij. Daarna is het oponthoud nog niet voorbij, bij Lelystad mag je eerst allemaal onoverzichterlijke woonwijken in voordat je weer op de dijk bent richting Ketelbrug. Dankzij de GPS kom ik er redelijk vlot doorheen, maar relaxed is anders, er moet doorgereden worden om niet te laat te komen.

Bij Ens stop ik voor boodschappen. Het is warm en ik ben duf. Het nog maar zo’n 30km en dat moet lukken in anderhalf uur. Ondanks ander oponthoud met openstaande bruggen ben ik braaf om 13:00 in Nijeveen en schrijf ik me in. Ymte is er ook en gaat rijden met koepeltje om het baanrecord verder te verbeteren. Ook Guus gaat met koepel rijden. Verder veel andere bekenden. Ik zet de tent op en gooi mijn zooi en die van anderen erin, en doe een poging tot powernap.

Rond 14:30 kunnen de ligfietsen van start. Het is benauwd, maar niet echt superwarm. Toch niet ideaal. Op het laatste moment besluit ik zonder schuimdeksel te gaan rijden. Zodra ik van start ben rijd ik na de eerste bocht 56km/h. De spieren geven signalen, auw! auw! Niet doen! Duidelijk gaar gereden van de heenrit in het warme weer. Na de 2e bocht gaat de snelheid met moeite richting de 53. Ik passeer Paulus. De bochten snijd ik slecht aan en ik verlies teveel snelheid. Dit gaat niet lekker. Na 2 bochten gaat het steeds vervelender. Ik schiet niet op. Zal ik stoppen? Nee, als je wilt stoppen gaat het juist goed, met die gedachten ga ik weer wat harder. Zie ik daar in de verte wat wits, Guus die 1 minuut voor mij gestart is? Ik ga weer wat harder. Helaas, dat bleek een container te zijn op een boerenerf. Ik passeer Magnus Hübel en roep Schneller! Schneller! Mijn quest is leeg en dat ben ik niet gewend en ik mis bagage om mijn ellebogen goed in te leggen. Bij een van de scherpe bochten vlieg ik op 2 wielen de berm in. Gelukkig gaat het net goed en ik kan verder rijden.

Foto: Marloes Dries

Ik passeer de start-finish met 53km/h, en gelukkig roepen mijn spieren steeds minder auw. Toch gaat het niet zo heel hard meer de 2e ronde, zo net 50 top. Verdorie! Normaal kan ik makkelijk 57 pieken als ik even een stuk tussen de auto’s meerrijd naar mijn werk. Op een recht stuk zie ik een tractor van een erf komen. Als dat maar goed gaat… Gelukkig gaat hij net op tijd aan de kant en ik bedank de chauffeur. In de verte… zie ik toch echt Guus rijden. Het laatste stukje doe ik een poging tot sprinten, wat niet gaat. Ik ben teleurgesteld. Van veel anderen hoor ik dat het ook niet zo geweldig ging. De quest van Stefan was bedekt met waterplanten en zwarte vlekken. Zijn rem had het begeven en hij was de sloot in gereden in de 1e ronde. Jammer, want hij was goed bezig. Ymte leek de enige te zijn waarbij het wel goed ging. De prijsuitrijking begint en ik slof er naar toe. Tot mijn verbazing blijk ik toch 2e te zijn geworden met ruim 48km/h.

Foto: Marloes Dries
Volgens de resultaten was ik net 2 seconden sneller dan Guus die met koepel reed en 3e werd. Ymte heeft het baanrecord verbeterd met 24:25 en reed gemiddeld ruim 53km/h. Pfoe, daar sta ik toch nog best ver vanaf, zelfs als het wel goed zou gaan. Nu ben ik eigenlijk ook 2e geworden bij gebrek aan echte concurentie want ik reed inderdaad zo’n 30 seconden trager op vorig jaar, toen met zwaarder lopende Quest 1 en meer tegenwind. Maar er is wel ruimte voor verbetering door betere voorbereiding, dat geeft weer een goed gevoel.

De 3×26″ quest van Theo bleek door z’n achterbrug te zijn gezakt. Gelukkig net na de wedstrijd. De schanieras blijkt te zijn gebroken, en met een stuk tak wordt de zaak op z’n plek gehouden.

Rond 18:00 vertrekken we vanuit Nijeveen richting Zwolle met Stefan, Paulus, Guus en Niels. Niels heeft er zin in en we rijden 38km/h. Paulus wijst de weg tot en met Zwolle. Daarna gaan we verder en we gaan steeds harder, ondanks ruim 200km en een wedstrijd in de benen. Guus zegt gedag bij Harderwijk en Niels en ik scheuren met zo’n 45km/h langs Ermelo en Nijkerk (klote rotondes!) richting Amersfoort. Dat je voor de quest weinig vermogen nodig hebt om vlak rechtuit te rijden en ik toch wel moe ben blijkt bij Amersfoort als de snelheid terugzakt naar 15km/h op het hellinkje voor de Stichtse Rotonde.

Vals plat langs Soesterberg nog even op volle snelheid en vlak voor De Bilt mag de snelheid eruit en het verzet op licht om het zuur uit de benen te trappelen en zo een hoop spierpijn later te vermijden. Rond 22:00 kom ik thuis met 310km op de teller. Een leuke dag al met al, en een lekkere terugrit met Niels.

Na een winter met voornamelijk Vredestein HPV banden gereden te hebben met de Quest, vond ik het tijd worden voor wat nieuws. Stiekem ook wel iets beters. De HPV’s scoren niet echt geweldig op het gebied van betrouwbaarheid en rolweerstand.

Zo’n 1,5 jaar geleden heb ik 3 Avocet FasGrip banden besteld. Vrij exclusieve banden die Harry Lieben uit de VS heeft geimporteerd. De kosten waren ongeveer 30 euro per band. Op het moment worden ze niet meer gemaakt.
Wim Schermer is vol lof over deze banden. Zelf heb ik er minder goede ervaring mee. De rubbersoort is vrij hard, waardoor de grip tegenvalt, vooral bij nat wegdek. Op de voorwielen was bij nat wegdek in de bocht snel sprake van onderstuur, en bij gebruik als achterband ben je verassend vaak en lang aan het spinnen bij vlot aanzetten. Ook had ik het idee dat ze niet echt snel waren. Nu in april de zomer weer in aantocht is en er mogelijk lagerproblemen waren in de tijd dat ik met de avocets heb gereden, vond ik het tijd om ze er maar weer eens om te leggen en te kijken wat ik ervan vind.

Vorige week heb ik de quest met deze banden geprobeerd tijdens een rondje van 75km met lekker zonnig weer, o.a. op de lekdijk tussen Houten en Amerongen. Het groffe asfalt word soepeltjes overwonnen en de snelheden waren niet mis, zo’n 50km kruissnelheid en uitschieter naar 65 op een stukje de dijk af. De Amerongse Berg af piekte zelfs op 81,0km/h. (ja inderdaad, veel te onverantwoord hard voor een smal 60km/h bosweggetje ) Tot nu toe kan ik er wel tevreden over zijn.

De Avocet zal ik alleen maar op op de voorwielen monteren. Op het achterwiel wil ik een band die meer grip heeft, om gevaarlijke situaties door overstuur te voorkomen.
Ook hier wil ik een vrij dikke band, voor lage rolweerstand en voldoende comfort, en om ongelijkheid tussen voor en achter te voorkomen. Ik heb daarvoor de Perfect Moiree 47-406 besteld, waar vrij goede ervaring over te vinden zijn. Komende week komt ie naar verwachting binnen bij mijn lokale fietsenwinkel.

The advantages are really there: no annoying NAT issues and no limitations to real Internet IP adresses. Even if you use it only for yourself, there’s a advantage when connecting multiple local areay networks, for example an backup server in network 2 that is pushed from several machines in network 1.

For a geek like me it’s even cooler if other internet services not under my control can be used via IPv6. Actually that is the situation where we all want to go in the future. There are already a few and 2,5% of the Mac users seem to be IPv6 connected. So now Google is entirely IPv6 enabled, however their DNS does not return any AAAA records. Following http://www.google.com/ipv6 only DNS resolvers on a whitelist will receive AAAA records because else the AAAA records could jeapordize their service availability because of poorly connected or configured network environments.

So how to get on the whitelist? There’s no need actually: XS4All has their IPv6 resolvers already on the whitelist. By using the resolvers 2001:888:0:9::99 and 2001:888:0:6::66 in /etc/fresolv.conf instead of your probably ordinary IPv4 resolvers, you will get connected to google by IPv6.

bastiaan@stofzuiger:~> host www.google.com
www.google.com is an alias for www.l.google.com.
www.l.google.com has address 74.125.77.103
www.l.google.com has address 74.125.77.104
www.l.google.com has address 74.125.77.99
www.l.google.com has address 74.125.77.147
www.l.google.com has IPv6 address 2001:4860:a005::68

w00t !

Are there any disadvantages? Probably there are. Beside the practical problems if the IPv6 link is down, your Google services will not work too, there are some privacy related concerns.
Because IPv6 adresses are auto generated from the MAC address, and every single device connects directly to the peer, the end site (Google here) can gather location related information much easier. How many computers are there in your network, what does there MAC address look like, etcetera. Read more about this.

/** @author Bastiaan Welmers
  *
  * 2009-01-13
  *
  * Holds memcache instance for caching stuff
  */

class Welmers_Memcache
{
	/**
	 * memcached ID for the ID list
	 */

	const IDLIST = '__idlist_RANDOMCHARS';

	/**
	 * Holds the memcache instance
	 */

	private static $_memcache;

	/**
	 * Holds the application key generated bij init()
	 * @see init()
	 */

	private static $_appKey;

	/**
	 * TTL of the objects in memcached in seconds
	 *
	 */

	public static $timeout = 1800;

	/**
	 * Get list of IDs
	 *
	 * @return array with queries as keys and unix timestamps as value
	 */

	public static function getIdList()
	{
		return self::get(self::IDLIST);
	}

	/**
	 * Get the queries that are cached in this object
	 * from memcache
	 *
	 * @param string unique ID to identify object
	 * @return mixed|bool object in cache, or false on error
	 */

	public static function get($id)
	{
		if (!self::$_memcache instanceof Memcache)
			self::init();

		return self::$_memcache->get(self::$_appKey . $id);

	}

	/**
	 * Store object into memcache
	 *
	 * @param string unique ID to identify object
	 * @param mixed object to store
	 * @return bool true on succes, false on failure
	 */

	public static function set($id, $value, $timeout = null)
	{
		if ($timeout == null)
			$timeout = self::$timeout;

		if (!self::$_memcache instanceof Memcache)
			self::init();

		if ($id != self::IDLIST)
		{ // save ID
			$idList = self::get(self::IDLIST);

			if (!is_array($idList))
				$idList = array();

			$idList[$id] = time() + $timeout;

			self::set(self::IDLIST, $idList, $timeout + 2);
		}

		return self::$_memcache->set(self::$_appKey . $id, $value, 0, $timeout);
	}

	/**
	 * expires (deletes) items from memcache
	 *
	 * @param string unique ID to identify object, ommit to flush entire cache (removes every stored object)
	 */

	public static function expire($id = null)
	{

		if (!self::$_memcache instanceof Memcache)
			self::init();

		$idList = self::get(self::IDLIST);

		if (!is_array($idList))
			$idList = array();

		if ($id == null)
		{ // remove all IDS
			foreach($idList as $expireId => $timeout)
			{
				self::$_memcache->delete($expireId);
			}
			$idList = array();
			self::set(self::IDLIST, $idList, self::$timeout);
		} else { //specific item
			if (isset($idList[$id]))
			{
				self::$_memcache->delete(self::$_appKey . $id);
				unset($idList[$id]);
				self::set(self::IDLIST, $idList, self::$timeout);
			}
		}
	}

	/**
	 * Initiates memcache.
	 *
	 * @param int $timeout TTL of every stored object, if ommitted, self::$timeout will be used, 1800 seconds.
	 */

	public static function init($timeout = null)
	{
		if ($timeout != null)
			self::$timeout = $timeout;

		self::$_memcache = new Memcache();
		self::$_memcache->connect('localhost', 11211) or die ("Could not connect to memcache");
		self::$_appKey = md5(__FILE__);
	}
}

Example for using this class:

function get_difficult_var()
{
      if (!$difficult_var = Welmers_Memcache::get('difficult_var'))
      {
          // difficult logic to create difficult var
          Welmers_Memcache::set('difficult_var', $difficult_var, 3600 /*timeout*/);
      }
      return $difficult_var
}

To remove this var, use

Welmers_Memcache::expire('difficult_var')

To expire everything inserted in this application:

Welmers_Memcache::expire()

The next class is useable for complicated MySQL queries, and replaces mysql_query.

/** @author Bastiaan Welmers
  *
  * 2009-01-13
  *
  * Cache mysql queries
  *
  */

class Welmers_Memcache_Db extends Welmers_Memcache
{
	/**
	 * IDPREFIX - salt prefix for memcached ID for queries
	 * should be random value
	 */

	const IDPREFIX = 'aasd79tpbo1234'; 

	/**
	 * QUERIES_PREFIX - prefix for memcached ID storing cached queries
	 */

	const QUERIES_PREFIX = '__queries';

	/**
	 * Get the queries that are cached in this object
	 *
	 * @return array with queries as keys
	 */

	public static function getQueries()
	{
		return self::get(self::IDPREFIX . self::QUERIES_PREFIX);
	}

	/**
	 * Get the queries that are cached in this object
	 *
	 * @return array with queries as keys
	 */

	private static function _saveQuery($sql)
	{
		$queries = self::get(self::IDPREFIX . self::QUERIES_PREFIX);
		if (!is_array($queries))
			$queries = array();
		$queries[$sql] = true;
		self::set(self::IDPREFIX . self::QUERIES_PREFIX, $queries, self::$timeout + 2);
	}

	/**
	 * Helper function for mysql_query and delete* functions
	 *
	 * @param string $sql SQL query
	 * @return string with ID for memcached for this query
	 */

	private static function _getQueryKey($sql)
	{
		return md5(self::IDPREFIX . $sql);
	}

	/**
	 * The cached version of the plain mysql_query funtion
	 * Returns multidimensional array with al return values.
	 *
	 * @param string $sql SQL query
	 * @param resource $linkIdentifier optional link identifier of the mysql connection
	 * @return array multidimensional array with all returned records
	 */

	public static function mysql_query($sql, $linkIdentifier = false)
	{

		if (!($cache = self::get(self::_getQueryKey($sql))))
		{
			$cache = array();
			$r = ($linkIdentifier !== false) ? mysql_query($sql, $linkIdentifier) : mysql_query($sql);
			if (is_resource($r) && (($rows = mysql_num_rows($r)) != 0))
			{
				for ($i=0; $i < $rows; $i++) {
					$fields = mysql_num_fields($r);
					$row = mysql_fetch_array($r);
					for ($j = 0; $j  $true)
			{
				if (strpos($query, $searchItem) !== false)
				{
					self::expire(self::_getQueryKey($query));
					unset($queries[$query]);
				}
			}
		}

		self::set(self::IDPREFIX . self::QUERIES_PREFIX, $queries, self::$timeout + 2);

	}

	/**
	 * Deletes all queries that are cached with this application
	 * Only use this for a global flush functionality, i.e. not for
	 * every change of a particular table.
	 * (then use deleteMatching('tablename') instead)
	 *
	 */

	public function deleteAll()
	{
		$queries = self::get(self::IDPREFIX . self::QUERIES_PREFIX);
		if (!is_array($queries))
			$queries = array();

		foreach($queries as $query => $true)
		{
			self::expire(self::_getQueryKey($query));
			unset($queries[$query]);
		}

		self::set(self::IDPREFIX . self::QUERIES_PREFIX, $queries, self::$timeout + 2);

	}
}

Example of this use would be easy:

// example query, quite complicated for mysql to calculate
$query = "SELECT
   DATE_FORMAT(lb.datum, '%Y') AS year,
   DATE_FORMAT(lb.datum, '%d-%m-%Y') AS datum_formatted,
   DATE_FORMAT(lb2.datum, '%d-%m-%Y') AS datum_tot_formatted,
lp.lidnummer, lp.bedrijfsnaam, lp.voornaam, lp.tussenvoegsel, lp.achternaam
FROM leden_betaalmethodearchief lb
LEFT JOIN leden_persoonlijk lp ON lp.lidnummer = lb.lidnummer
LEFT JOIN leden_betaalmethodearchief lb2 ON
       lb.lidnummer = lb2.lidnummer AND
       lb2.datum > lb.datum AND
       lb2.betaalmethode != 'acceptgiro'
WHERE lb.betaalmethode = 'acceptgiro' ORDER BY lb.datum ASC
";
$result = Welmers_Memcache_Db::mysql_query($query);
// instead of $result = mysql_query($query)

foreach($result as $row) {
// instead of while ($row = mysql_fetch_assoc($result) {
     print $row['field'];
     // …..
}

Have a lot of fun!

Like IMO all modern applications should, my application only uses UTF-8 for displaying and handling all non-ASCII characters. To make the MySQL server understand that I talk UTF-8 to it, I always use the following immediately after connecting:

SET NAMES utf8;
SET CHARACTER SET utf8;

The PDO interface of PHP, that Zend_Db is using, doesn’t use this, resulting in wrong character encoding (probably, the default is still latin-9 or something)
To solve this, you can extend the Zend_Db_Adapter_Pdo_Mysql class and use the extended class instead for setting up the connection in bootstrap.php:

class DbAdapter_Pdo_Mysql extends Zend_Db_Adapter_Pdo_Mysql {

   protected function _connect() {
       // if we already have a PDO object, no need to re-connect.
       if ($this->_connection)
            return;

        parent::_connect();

        $this->query('SET NAMES utf8');
        $this->query('SET CHARACTER SET utf8');
    }
}

Now replace code like this in your bootstrap.ini:

$dbAdapter = new Zend_Db_Adapter_Pdo_Mysql(array(
             'host' => 'localhost',
             'username' => $dbuser,
             'password' => $dbpass,
             'dbname' => $db
             ));

$registry->set('dbAdapter', $dbAdapter);

Zend_Db_Table_Abstract::setDefaultAdapter($dbAdapter);

by this:

$dbAdapter = new DbAdapter_Pdo_Mysql(array(
             'host' => 'localhost',
             'username' => $dbuser,
             'password' => $dbpass,
             'dbname' => $db
             ));

$registry->set('dbAdapter', $dbAdapter);

Zend_Db_Table_Abstract::setDefaultAdapter($dbAdapter);

Wow, problem solved That’s an easy character encoding problemen today