The first step for installing PHP 5.3 is to get the prerequisites. For this guide you will need the following libraries in order to compile php with the options that I use. If you have some custom libraries/extensions that you want included in your build of PHP, now is the time to install them if you haven’t already.

The following command will install the libraries that I will need:

sudo apt-get install libmcrypt-dev libxml2 libxml2-dev libbz2-dev libcurl4-gnutls-dev libjpeg62-dbg libpng12-dev libxslt1-dev libbz2-dev

Once our required libraries have been installed we can go to http://www.php.net/downloads.php and choose to download the latest 5.3.x build in tar.gz format. I chose to copy the download link and use wget to download it to the tmp directory, but you can do whatever you like.

cd /tmp
wget http://ca2.php.net/get/php-5.3.1.tar.gz/from/this/mirror

now untar the file and go into the directory

tar -xvf php-5.3.1.tar.gz
cd php-5.3.1

Now comes the fun part. Here we will run the configure script that says what kind of extensions we want php built with. At the beginning of the tutorial we installed a bunch of libraries (for example libbz2) and because of that we are able to build PHP with support for these libraries by specifying the –with-%library% flag. To see the options available for configuring php type:

./configure --help

You should be fine using what I used below, but feel free to make adjustments as you see fit:

./configure --prefix=/usr --with-config-file-path=/etc/php5/ --with-config-file-scan-dir=/etc/php5/ --with-apxs2=/usr/bin/apxs2 --with-bz2 --with-curl --with-gd --with-iconv --with-mcrypt --with-mysql --with-mysqli --with-openssl --with-pcre-regex --with-pdo-mysql --with-pear --with-xmlrpc --with-xsl --with-zlib --enable-ftp --enable-mbstring --enable-soap --enable-sockets

If all goes well with the configure script you can continue to run the make file:

sudo make -i install

Once the make script is finished running we have to manually create the modules for Apache:

cd /etc/apache2/mods-available
sudo nano php5.load

The contents of this file should be:

LoadModule php5_module /usr/lib/apache2/modules/libphp5.so

Now create the configuration file:

sudo nano php5.conf

with the contents:

<IfModule mod_php5.c>
	AddType application/x-httpd-php .php .phtml .php3
	AddType application/x-httpd-php-source .phps
</IfModule>

Once those two files have been created we can enable the php5 module for Apache, then restart Apache for the new module to load.

sudo a2enmod php5
sudo /etc/init.d/apache2 restart

Now go into your web directory (if you followed my apache guide earlier go to ~/www/sandbox.loc/httpdocs) and create a file called test.php

nano ~/www/sandbox.loc/httpdocs/test.php

with the following contents:

<?php echo phpinfo(); ?>

Now point your web browser to the new file you created. Which should be at http://sandbox.loc/test.php, you should get a phpinfo page if all went according to plan.

You have now successfully installed php 5.3. On the phpinfo page if you scroll down to the date section you will probably see an error saying you have to set your timezone. You can do this with the php.ini file. To ceate the php in file first create the /etc/php5 directory and copy the php.ini-production file included in the php-5.3.1 tar file.

sudo mkdir /etc/php5
sudo cp /tmp/php-5.3.1/php.ini-production /etc/php5/php.ini

Now edit the php.ini file:

sudo nano /etc/php5/php.ini

and find the line beginning with “;date.timezone”, remove the semi-colon and set the value to your desired time zone. There is a list of supported timezones in the PHP manual. For example, I changed mine to:

date.timezone = "America/Edmonton"

You should now be set to start using PHP 5.3 with Apache!

This is a great tool for Splunk. All you have to do is copy an event that you want to capture a custom field in, paste it in the tool, then work with the regular expression until it captures that data you need. One example of a regular expression that I built is this monster:

(http|https)://(([A-Za-z0-9\.\-]*)?\.)?(?<domain_name>[A-Za-z0-9\-]{3}[A-Za-z0-9\-]*\.([A-Za-z]{2}\.[A-Za-z]{2}|[A-Za-z]{2,3})|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})

I’ll explain what this one does in a second, but you can probably guess just by looking at it. With Splunk I am indexing all data that goes through the HTTP proxy on the firewall. Each event that Splunk indexes from the proxy includes the address processessed, right down to the file name. However, I’m more interested in pooling all of the events by domain name to get total amount of requests, time spent, etc by domain name. So, I needed a regular expression to extract the domain name; enter the mess of characters from above.

The regular expression above will break down a URL and capture its domain name. For example the regex will capture example.com from the following url:

http://www.example.com/some_folder/filename.php?id=34&name=something

This is actually simple enough to capture but became more complex when you considered the following:

• Subdomains (whatever.example.com)
• Odd domain extensions (ab.ca, co.uk)
• IP Address domains (64.75.34.12)

Here is a break down of the regular expression mentioned above.

Capture group 1:

(http|https)://

Pretty straight forward, the url must begin with http or https. This is a HTTP/S proxy so I know that it will begin with either of these two values. If you were to use this for an FTP proxy you could easily put in ftp. The http/s is always followed by ://.

Capture Group 2:

([A-Za-z0-9\.\-]*\.)?

This part of the expression is to capture the subdomain. It looks for any number containing characters in the range A-Z, a-z, 0-9, ., and – followed by a . (dot). The question mark at the end of this part of the expression means that it is optional, that is, not all URL’s have subdomains. Now that we have the subdomain, the next thing to process will be the domain name.

Capture Group 3 (this one’s a doosey):

([A-Za-z0-9\-]{3}[A-Za-z0-9\-]*\.([A-Za-z]{2}\.[A-Za-z]{2}|[A-Za-z]{2s,4})|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})

This one is so long because it looks for a domain name, or an IP address. Here is the part that captures a domain name:

([A-Za-z0-9\-]{2}[A-Za-z0-9\-]*\.[A-Za-z]{2}\.[A-Za-z]{2}|[A-Za-z]{2,6})

A domain name must be at lease 2 characters, the first part takes care of that: [A-Za-z0-9\-]{2}.

The expression that follows that captures the remaining characters in the domain up until the “.” before the domain extension: [A-Za-z0-9\-]*\.

The final part captures the domain extension, which can sometimes be a provice/state followed by a country code (ab.ca or fl.us which is ([A-Za-z]{2}\.[A-Za-z]{2}) or (|) an extension from two characters (ie: .ca) to six characters (ie: .museum) which is represented by [A-Za-z]{2,6}.

I also wanted to capture the IP address if the http request used an IP instead of a host name. That’s what the last part captures:

[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}

This one is fairly easy as well. An Ipv4 address is just a series of 1 to 3 digits, a dot, 1 to 3 digits, a dot, 1 to 3 digits, a dot, then 1 to 3 digits. That is what the above captures.

To reiterate, the full regular expression is:

(http|https)://(([A-Za-z0-9\.\-]*)?\.)?(?<domain_name>[A-Za-z0-9\-]{3}[A-Za-z0-9\-]*\.([A-Za-z]{2}\.[A-Za-z]{2}|[A-Za-z]{2,3})|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})

You may be wondering what the ? is for. That is just a way to assign the value of the 4th capture group a variable named “domain_name” in Splunk. If you take out the ? capture group 4 will still contain the domain name.

I feel that learning and becoming comfortable with regular expressions is extremely important if you do any kind of programming. At first they may seem a little daunting, but once you get the patterns down they are actually quite simple to write. They allow you to parse almost any kind of data and nearly every programming language has some kind of implementation for them. Using a tool like RegExr is a great way to learn to write regular expressions and also test them out once you get the hang of it. You can also find a large library of regular expressions at regexlib.com.

Regular Expression Links:

• RegExr – Regular Expression Testing Tool
• RegExLib.com – A collection of regular expressions
• An Introduction to Regular Expressions

It is indeed a problem with a security module in Apache. If you are as unlucky as I was to still have the problem after trying out the solutions in the blog post above, then you have the joy of tracking down the specific word that appears to be the problem. In my case, I was posting a code snippet from my post on Caching Data with CakePHP. For some reason mod_security was flagging my use of the word “settings”. Once I changed the variable names in the post it worked flawlessly.

The Cache Function

CakePHP’s cache function is quite easy to use. The code snippet below shows how to use it.

1
2
3
4
5
6
7
8
9
10
11

$cache_name = 'query';
$cache_data = Cache::read($cache_name);
if (empty($cache_data))
{
	$dataModel = $this->Model->find('first');
	Cache::write($cache_name, $dataModel, array('config' => 'File', 'duration' => 7200));
}
else
{
	$dataModel = $cache_data;
}

The code above attempts to read in the data from the cache, given the $cache_name. If the data is not found, the query is executed and then written to the cache. As you can see in the Cache::write I am using the File engine for caching, but you can use whichever you desire. I also set the duration to 7200 seconds (2 hours). If the cache data IS found then the query is skipped and the cache data is assigned to $dataModel. Pretty nifty eh?

I also believe that when you do a save operation on the Settings model Cake knows to automatically remove that cache data, so you don’t end up with out of sync info! If for some reason you want to manually delete the cached data you can use: Cache::delete($key) for a specific key, or Cache::clear() to delete everything in the cache.

1
2
3

if (!defined('CAKE_CORE_INCLUDE_PATH')) {
	define('CAKE_CORE_INCLUDE_PATH', ROOT);
}

with this:

1
2
3

if (!defined('CAKE_CORE_INCLUDE_PATH')) {
	define('CAKE_CORE_INCLUDE_PATH', DS . 'usr' . DS . 'lib' . DS . 'php' . DS . 'cake');
}

You are now using the common cake core. When a new update comes out to the library, just replace the files in /usr/lib/php/cake with the new version!

If you want to go a step further and share some of your own models, views, controllers, behaviors, helpers, or components between applications you can use a similar technique. For example create a folder in ‘/usr/lib/php/models’ and put all your common models in that folder, then in your application open up bootstrap.php and add the following:

1
2
3

$modelPaths = array(
DS . 'usr' . DS . 'lib' . DS . 'php' . DS . 'models'
);

Like I said the same thing can be done with views, controllers, helpers, behaviors or components. The cookbook says how! This is pretty handy for when you find a bug in a model and you have several applications using that model!

Automagic Forms!

Using $form->input() is great, but when you have many fields or you are just creating a quick form there is a better way! The key is to set up your database table structure properly. If you follow the naming conventions creating a form is as easy as using the following code in the view (this is for a Contact model… obviously):

1
2
3
4
5

<php
echo $form->create('Contact');
echo $form->inputs();
echo $form->end("Save Contact");
?>

This is pretty nice, but what happens if you have fields that you don’t want the user to fill out? Use the blacklist! The following code removes the fieldset and legend along with the fields id, created, and modified.

1
2
3
4
5
6
7

<php
$inputs = array('fieldset' => false, 'legend' => false);
$blacklist = array('id', 'created', 'modified');
echo $form->create('Contact');
echo $form->inputs($inputs, $blacklist);
echo $form->end("Save Contact");
?>

Not too bad. Fully functional form in 5 lines of code! But wait… There’s more! You may still want to customize the form a little more to add certain options to some fields. This can be done with the $inputs array. Basically all you have to do is add a key in the $inputs array with the field name, and then assign the optional attributes as you would if you were using the $form->input() function. Here is an example of what the array would look like to add a hint after the “first name” field.

1
2
3
4
5

$inputs = array(
	'fieldset' => false,
	'legend' => false,
	'first_name' => array('after' => 'i.e. Lane')
);

The only drawback with assigning the optional attributes is that now the $inputs array must contain a key for every input you want to have a form field for. I’m sure that there is a better way to do this, but you could do something like this in the controller:

1
2
3
4
5
6
7
8
9
10

<php
function add()
{
	$schema = $this->Contact->schema();
	foreach($schema as &amp;$field)
		$field = array();
	unset($field);
	$this->set(compact('schema'));
}
?>

and then in the view do this:

1
2
3

$inputs = array('fieldset' => false, 'legend' => false);
$inputs = array_merge($inputs, $schema);
$inputs['first_name'] = array('after' => 'i.e. Lane');

This method would get the job done, but would really only be practical if you had a whole bunch of fields. Otherwise creating each $form->input() might be the way to go if you have to assign some options. Nonetheless, I’ve found that you can bypass having to set the $options array for specific fields by following the naming conventions, and when that is the case there is nothing better than $form->inputs()!

Related Links

• The Form Helper
• Form Helper API

What is MVC anyway?

MVC stands for Model-View-Controller.  MVC is a well known design pattern that basically keeps that data handling, application flow, and presentation seperate from each other.  At first it may seem a little confusing, but it makes coding much easier and efficient.  I will explain each aspect of the MVC below relative to a simple application to manage contacts.

The Model

The model is responsible for handling all of the data.  In CakePHP each model usually corresponds to a table in the database.  So if in our database we have a table named “contacts” to store all of our contacts then there will be a model named “Contact”.  The plural and singular convention is important but I will not be explaining it at this time.  I recommend you read the CakePHP conventions before you actually start using Cake because they will save you time and headaches.  You can just trust me that the model name should be singular, and the database table should be plural.  Here is a rough example of what a model would look like in CakePHP.  This file would be stored at “/app/models/contact.php”:

1
2
3
4
5
6

<?php 
class Contact extends AppModel 
{ 
     var $name = 'Contact'; 
}
?>

This is actually all you need to get started with a basic model in CakePHP.  As you can see the class Contact extends the class AppModel so it inherits all of the functions that AppModel has access to.  The AppModel has functions like find, save, delete, etc that allow you to interact with the database.  The model should be responsible for all interaction with the database.

So in review, anything to do with manipulating data should be done in the model.  Whether it is a query to CRUD (create, read, update, delete) operations to the database you should be doing it from the model.  Extending Cake’s AppModel class allows you to use the built in functions for CRUD operations so that you should never have to write an SQL query again!  If you would like to learn more about the model and the functions available to it check out the Models page in the Cookbook.

The View

The view is what it sounds like.  It is the presentation layer, everything that has to do with displaying the data is done in the view.  In cakePHP the view is set up in templates that displays data that is obtained from the model.  The view should be the only place where HTML resides.  This makes things a lot easier when it comes to modifying the look and feel of an application without having to touch the guts.  The view is basically a template and in CakePHP they have the extension “ctp”.  Here is what and example of what the view would look like to display a list of contacts… lets call it “index.ctp”.  In an application setting this file would be stored in the folder “/app/views/contacts”.

1
2
3
4
5
6
7

<div class="contacts">
<?php foreach($contacts as $contact): ?>
<span class="contact-name">
<?php echo $contact['Contact']['name']; ?>
</span>
<?php endforeach; ?>
</div>

Of course this is an extremely basic example of printing out a list of contact names.  In the view we would definitely want to present more information in a nicer way… the best part is in order to do that the only file we will have to edit is the view.  You’re probably wondering where the $contacts variable came from, this brings us to the controller.

The Controller

Lastly, there is the controller.  The controller manages the flow of the application.  It is responsible for handling requests and passing the proper information for the given request.  The controller consists of several functions, called “actions”, which determine what should be done.  Each action (usually) has an associated view.  So for example, if we have an action called “index” in our controller we will need a view called “index.ctp” that displays the information for the given action.  The view in the example above uses a variable called $contact.  That variable is set using the controller.  Here is an example that ties in with the above view, this file would be “/app/controllers/contacts_controller.php” in an application setting.

1
2
3
4
5
6
7
8
9
10
11

<?php
class ContactsController extends AppController
{
	var $name = 'Contacts';
	function index()
	{
		$contacts = $this->Contact->find('all');
		$this->set('contacts');
	}
}
?>

The function in the controller above asks the Contact model to find all of the entries in the associated contacts table and then assigns it to the variable $contacts.   Afterwards the controller sets the variable $contacts so that the view can now use the $contacts variable.  The built in libraries will automatically search for the file “/app/views/contacts/index.ctp” and use it to display the information passed. The best convention is to keep the code in the controllers to a minimum and instead put the bulk of the code for manipulating the data into the model (see Fat Models, Skinny Controllers by Chris Hartjes).

Putting It All Together

So there you have it, we just created an extremely simple Model, View, and Controller for listing contacts.  Of course from here you would build on creating actions in the controller for add, view, edit, etc. and views to go with those actions.  But hopefully this gives you some insight in to how it works.  If you have never followed this design practice before you are probably wondering some of the benefits of the MVC practice.  It may not be immediately apparent, but there are several.  First of all, separating code in this method allows the basic functionality of the code to be reused over and over again.  When it comes to modifying the way the application looks you only have to edit the views instead of all of the code.  This allows someone who is familiar with HTML to customize the look of things without having to search endless lines of code that may not be familiar to them.  It also makes debugging much easier because you can pinpoint exactly where the problems may be coming from.  If the data isn’t correct, it must be the model… If something is funky with the way it is displayed, it has got to be the view… and so on.  This is of course just one of the great design patterns used by Cake and there are several others that will save time and headaches.

Additional MVC Articles

• MVC on Wikipedia
• The CakePHP Manual MVC documentation
• Cookbook entry for Models
• Cookbook entry for Views
• Cookbook entry for Controllers