I updated the script to make sure that it serves the same image from the same domain on each request. It’s counter productive to send the same image from different url’s as this increases the download time. This fix does not hash or internally check the image to see if it is identical to another image with a different name. This also does not store anything in a file or database, so it’s possible that the image will be served from a different url on a different page / request.

This is a drop in replacement for the original script. The interface for cdn_image_url and cdn_image_tag methods did not change.

Original Information

In order to reduce page latency, I’ve been implementing a parallel content delivery network on a large symfony project. This code should work on symfony and most any other php based site. What it does is allow a developer to specify a number of subdomains / domains for content delivery, such as content1.mydomain, content2.mydomain, etc… When serving images in this manner, one can greatly reduce page loading time by using multiple domains for images even if the domains are on the same server.

This script uses a singleton hack to keep a cursor of the current domain that the image is being served from. It then delivers the image in sequential order from the list of domains that the developer has pre-specified. A developer can specify as many domains as they want, and if the page is being served over a secure connection, the script will automatically include secure versions of the images. NOTE: make sure the domains have ssl installed correctly or errors will occur.

Add this script to a file in /myproject/lib/.

<?php
 
class Cdn {
 
    private $current_cdn;
    private $is_secure = 'http://';
    private $prefix_match = array();
    private static $instance;
    private static $domain = 'mydomain.com';
    private static $cdn = array('www.', 'cd1.', 'cd2.');
 
    private function __construct() {
 
        $this->current_cdn = 0;
 
        if ($_SERVER['SERVER_PORT'] == '443') {
 
            $this->is_secure = 'https://';
        }
    }
 
    public function cdn_image_url($image_path) {
 
        $cdn = $this->get_cdn($image_path);
 
        return $this->is_secure . $cdn . self::$domain . '/' . $image_path;
    }
 
    public function cdn_image_tag($image_path, $option_array=array()) {
 
        $options = null;
 
        $cdn = $this->get_cdn($image_path);
 
        if (count($option_array) > 0) {
            foreach ($option_array as $key => $attribute) {
                $options .= $key . '="' . $attribute . '" ';
            }
        }
 
        return '<img src="' . $this->is_secure . $cdn . self::$domain . '/' . $image_path . '" ' . $options . ' />';
    }
 
    private function get_cdn($image_path) {
 
        if (!isset(self::$cdn[$this->current_cdn])) {
            $this->current_cdn = 0;
        }
 
        if (array_key_exists($image_path, $this->prefix_match)) {
 
            $cdn = $this->prefix_match[$image_path];
        } else {
 
            $cdn = self::$cdn[$this->current_cdn];
        }
 
        $this->prefix_match[$image_path] = $cdn;
 
        $this->current_cdn++;
 
        return $cdn;
    }
 
    public static function getInstance() {
        if(self::$instance == NULL) self::$instance = new Cdn;
        return self::$instance;
    }
 
}

Then you can call your images using 1 of 2 methods throughout the project and they will be delivered sequentially through all of the domains in your CDN.

If you would just like the image url:

 $my_url = Cdn::getInstance()->cdn_image_url('images/my_image.jpg');

If you want the entire tag:

 echo Cdn::getInstance()->cdn_image_tag('images/swiped-box-b.jpg');

You can also add attributes to the tag:

 echo Cdn::getInstance()->cdn_image_tag('images/swiped-box-b.jpg', array('alt' => 'My Image'));

If your images are hosted on completely different domains, simply edit the $cdn property to include the full domain, and take out the self::$domain property from the appropriate method: cdn_image_url or cdn_image_tag.

This is a very basic class for delivering images from different domains. It does not take things into account like serving the same image from the same domain every time to take advantage of caching, or checking to see if the image actually exists. However, it should provide a basis for a more complete content delivery script.

To start off with, the chart image must be delivered from a secure connection. Google doesn’t allow this plain and simple, so we need to figure out how to host it from our own site. We accomplish this by fetching the image from google using the standard API, writing it to a file, and then calling it on our own script. We basically make a image handling proxy.

Let’s take a simple google chart to experiment with.

$chart_image = 'http://chart.apis.google.com/chart?chs=500x50&chf=bg,s,ffffff&cht=ls&chd=t:23.52,20.58,26.47,23.52,23.52,23.52,100.00,0.00,23.52,23.52,27.94,20.58,23.52&chco=0066ff';

Next we need to make a function to fetch and save the google chart locally. It will check the chart against the local copy and save it if the chart doesn’t exist, or the image has changed. This way we aren’t re-writing the same chart on every request, but if the chart changes, it will be updated appropriately.

 
	public static function saveImage($chart_url,$path,$file_name){
            if(!file_exists($path.$file_name) || (md5_file($path.$file_name) != md5_file($chart_url)))
            {
                file_put_contents($path.$file_name,file_get_contents($chart_url));
            }
 
            return $file_name;
	}

Lastly we tie it all together so that it is usable in our application. Im using this within a class, but this could just be used as a function as well. Your image directory will need to be writable for this to work.

 
public function doSomething()
{
 
$local_image_path = '/path/to/images/charts/';
$image_name = 'some_chart_image.png';
$chart_url = 'http://chart.apis.google.com/chart?chs=500x50&chf=bg,s,ffffff&cht=ls&chd=t:23.52,20.58,26.47,23.52,23.52,23.52,100.00,0.00,23.52,23.52,27.94,20.58,23.52&chco=0066ff';
 
$image = self::saveImage($chart_url ,$local_image_path,$image_name);
 
}

You’ll need to implement your own error handling, and adjust this to meet the paths and specifics of your server, but the image can now be called from:
<img src="/images/charts/some_chart_image.png" alt="" />

If you need help creating your base chart image, this tool is a great place to start.

PHP Snippets:

//states and abbreviations snippets
$states = array('Alaska','Alabama','Arkansas','Arizona','California','Colorado','Connecticut','Delaware','Florida','Georgia','Hawaii','Iowa','Idaho','Illinois','Indiana','Kansas','Kentucky','Louisiana','Massachusetts','Maryland','Maine','Michigan','Minnesota','Missouri','Mississippi','Montana','North Carolina','North Dakota','Nebraska','New Hampshire','New Jersey','New Mexico','Nevada','New York','Ohio','Oklahoma','Oregon','Pennsylvania','Rhode Island','South Carolina','South Dakota','Tennessee','Texas','Utah','Virginia','Vermont','Washington','Wisconsin','West Virginia','Wyoming');
 
$abbreviations = array('AK','AL','AR','AZ','CA','CO','CT','DE','FL','GA','HI','IA','ID','IL','IN','KS','KY','LA','MA','MD','ME','MI','MN','MO','MS','MT','NC','ND','NE','NH','NJ','NM','NV','NY','OH','OK','OR','PA','RI','SC','SD','TN','TX','UT','VA','VT','WA','WI','WV','WY');
 
$states_assoc = array(
'AL'=>"Alabama",  
'AK'=>"Alaska",  
'AZ'=>"Arizona",  
'AR'=>"Arkansas",  
'CA'=>"California",  
'CO'=>"Colorado",  
'CT'=>"Connecticut",  
'DE'=>"Delaware",  
'DC'=>"District Of Columbia",  
'FL'=>"Florida",  
'GA'=>"Georgia",  
'HI'=>"Hawaii",  
'ID'=>"Idaho",  
'IL'=>"Illinois",  
'IN'=>"Indiana",  
'IA'=>"Iowa",  
'KS'=>"Kansas",  
'KY'=>"Kentucky",  
'LA'=>"Louisiana",  
'ME'=>"Maine",  
'MD'=>"Maryland",  
'MA'=>"Massachusetts",  
'MI'=>"Michigan",  
'MN'=>"Minnesota",  
'MS'=>"Mississippi",  
'MO'=>"Missouri",  
'MT'=>"Montana",
'NE'=>"Nebraska",
'NV'=>"Nevada",
'NH'=>"New Hampshire",
'NJ'=>"New Jersey",
'NM'=>"New Mexico",
'NY'=>"New York",
'NC'=>"North Carolina",
'ND'=>"North Dakota",
'OH'=>"Ohio",  
'OK'=>"Oklahoma",  
'OR'=>"Oregon",  
'PA'=>"Pennsylvania",  
'RI'=>"Rhode Island",  
'SC'=>"South Carolina",  
'SD'=>"South Dakota",
'TN'=>"Tennessee",  
'TX'=>"Texas",  
'UT'=>"Utah",  
'VT'=>"Vermont",  
'VA'=>"Virginia",  
'WA'=>"Washington",  
'WV'=>"West Virginia",  
'WI'=>"Wisconsin",  
'WY'=>"Wyoming");

MySQL Snippets:
[sql]
– —————————-
– Table structure for states
– —————————-
CREATE TABLE `states` (
`state_id` tinyint(3) unsigned NOT NULL,
`state_name` varchar(22) NOT NULL,
`state_abbreviation` char(2) NOT NULL,
PRIMARY KEY (`state_id`),
UNIQUE KEY `state_abbreviation` (`state_abbreviation`)
) ENGINE=InnoDB AUTO_INCREMENT=52 DEFAULT CHARSET=utf8;

– —————————-
– Records
– —————————-
INSERT INTO `states` VALUES (’1′, ‘Alabama’, ‘AL’);
INSERT INTO `states` VALUES (’2′, ‘Alaska’, ‘AK’);
INSERT INTO `states` VALUES (’3′, ‘Arizona’, ‘AZ’);
INSERT INTO `states` VALUES (’4′, ‘Arkansas’, ‘AR’);
INSERT INTO `states` VALUES (’5′, ‘California’, ‘CA’);
INSERT INTO `states` VALUES (’6′, ‘Colorado’, ‘CO’);
INSERT INTO `states` VALUES (’7′, ‘Connecticut’, ‘CT’);
INSERT INTO `states` VALUES (’8′, ‘Delaware’, ‘DE’);
INSERT INTO `states` VALUES (’9′, ‘District of Columbia’, ‘DC’);
INSERT INTO `states` VALUES (’10′, ‘Florida’, ‘FL’);
INSERT INTO `states` VALUES (’11′, ‘Georgia’, ‘GA’);
INSERT INTO `states` VALUES (’12′, ‘Hawaii’, ‘HI’);
INSERT INTO `states` VALUES (’13′, ‘Idaho’, ‘ID’);
INSERT INTO `states` VALUES (’14′, ‘Illinois’, ‘IL’);
INSERT INTO `states` VALUES (’15′, ‘Indiana’, ‘IN’);
INSERT INTO `states` VALUES (’16′, ‘Iowa’, ‘IA’);
INSERT INTO `states` VALUES (’17′, ‘Kansas’, ‘KS’);
INSERT INTO `states` VALUES (’18′, ‘Kentucky’, ‘KY’);
INSERT INTO `states` VALUES (’19′, ‘Louisiana’, ‘LA’);
INSERT INTO `states` VALUES (’20′, ‘Maine’, ‘ME’);
INSERT INTO `states` VALUES (’21′, ‘Maryland’, ‘MD’);
INSERT INTO `states` VALUES (’22′, ‘Massachusetts’, ‘MA’);
INSERT INTO `states` VALUES (’23′, ‘Michigan’, ‘MI’);
INSERT INTO `states` VALUES (’24′, ‘Minnesota’, ‘MN’);
INSERT INTO `states` VALUES (’25′, ‘Mississippi’, ‘MS’);
INSERT INTO `states` VALUES (’26′, ‘Missouri’, ‘MO’);
INSERT INTO `states` VALUES (’27′, ‘Montana’, ‘MT’);
INSERT INTO `states` VALUES (’28′, ‘Nebraska’, ‘NE’);
INSERT INTO `states` VALUES (’29′, ‘Nevada’, ‘NV’);
INSERT INTO `states` VALUES (’30′, ‘New Hampshire’, ‘NH’);
INSERT INTO `states` VALUES (’31′, ‘New Jersey’, ‘NJ’);
INSERT INTO `states` VALUES (’32′, ‘New Mexico’, ‘NM’);
INSERT INTO `states` VALUES (’33′, ‘New York’, ‘NY’);
INSERT INTO `states` VALUES (’34′, ‘North Carolina’, ‘NC’);
INSERT INTO `states` VALUES (’35′, ‘North Dakota’, ‘ND’);
INSERT INTO `states` VALUES (’36′, ‘Ohio’, ‘OH’);
INSERT INTO `states` VALUES (’37′, ‘Oklahoma’, ‘OK’);
INSERT INTO `states` VALUES (’38′, ‘Oregon’, ‘OR’);
INSERT INTO `states` VALUES (’39′, ‘Pennsylvania’, ‘PA’);
INSERT INTO `states` VALUES (’40′, ‘Rhode Island’, ‘RI’);
INSERT INTO `states` VALUES (’41′, ‘South Carolina’, ‘SC’);
INSERT INTO `states` VALUES (’42′, ‘South Dakota’, ‘SD’);
INSERT INTO `states` VALUES (’43′, ‘Tennessee’, ‘TN’);
INSERT INTO `states` VALUES (’44′, ‘Texas’, ‘TX’);
INSERT INTO `states` VALUES (’45′, ‘Utah’, ‘UT’);
INSERT INTO `states` VALUES (’46′, ‘Vermont’, ‘VT’);
INSERT INTO `states` VALUES (’47′, ‘Virginia’, ‘VA’);
INSERT INTO `states` VALUES (’48′, ‘Washington’, ‘WA’);
INSERT INTO `states` VALUES (’49′, ‘West Virginia’, ‘WV’);
INSERT INTO `states` VALUES (’50′, ‘Wisconsin’, ‘WI’);
INSERT INTO `states` VALUES (’51′, ‘Wyoming’, ‘WY’);
[/sql]

/**
 * Benchmark a php script
 *
 * @param array $time_sample
 * @return string HTML
 */
function quick_benchmark($time_sample = array())
{
	$steps = count($time_sample);
	$output = '';
 
	for($i=0;$i<$steps;$i++)
	{
		if($i<($steps-1))
		{
			$output .= '<p>Time '. ($i+1) .': '. number_format(($time_sample[$i+1] - $time_sample[$i]),6,'.','') .' seconds.</p>';
		}
	}
 
	$output .= '<p>Total time: '. number_format(($time_sample[$steps-1] - $time_sample[0]),6,'.','') .' seconds.</p>';
 
	return $output;
}

This is a simple example using sleep() to demonstrate the output.

$time_sample[] = microtime(true); //start
sleep(1);
$time_sample[] = microtime(true); //time 1
sleep(2);
$time_sample[] = microtime(true); //time 2
sleep(3);
$time_sample[] = microtime(true); //time 3
sleep(1);
$time_sample[] = microtime(true); //time 4
 
echo quick_benchmark($time_sample);

The script outputs:

Time 1: 1.001833 seconds.
Time 2: 2.001427 seconds.
Time 3: 3.001124 seconds.
Time 4: 1.001720 seconds.
Total time: 7.006104 seconds.

It’s a good idea to comment each time you record a microtime so that you know which section of script took that amount of time.

This can be used to generate random passwords or keys or just about anything else that needs a random string. You can also throw this directly into a class and use it as a static method.

 
/**
 * Generate a random string
 *
 * @param int $length
 * @param int $mode 1 = Alpha, 2 = Alpha-numeric, 3 = Alpha-numeric with symbols
 * @param boolian $char_set Set true for Upper and Lower case letters
 * @return string 
 */
function random_string($length=16,$mode=1,$char_set=false)
{
	$string = '';
	$possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
	if($char_set) {
 
		$possible .= strtolower($possible);
 
	}
 
	switch($mode) {
 
		case 3:
 
			$possible .= '`~!@#$%^&*()_-+=|}]{[":;<,>.?/';
 
		case 2:
 
			$possible .= '0123456789';
			break;
 
	}
 
	for($i=1;$i<$length;$i++) {
		$char = substr($possible, mt_rand(0, strlen($possible)-1), 1);
		$string .= $char;
	}
 
	return $string;
}

Examples:

echo random_string(32);
//WQTISVJVMWSEFXEIQISJPCBENFEHQAN

echo random_string(16,2,true);
//cZhVGHJb0PqJIk3

echo random_string(16,3);
//=,:UT__GN[ST>GH

Symfony when using Propel does not have native support for using NOT IN queries in reference to another tables. You can use NOT IN and an array, but cannot use NOT IN with reference to another table.

Here’s how to use NOT IN other_table with Propel and Symfony. Let’s pretend we need to run this query.

SELECT * FROM my_table_1 WHERE id NOT IN (
SELECT id FROM my_table_2);

Using Propel and Criteria, there is no native way of running this query. But, with the Criteria::CUSTOM modifier, we can force this query through propel.

It’s actually very easy.

 
$c = new Criteria;
 
/* Example query
$not_in_query = 'my_table_1.id NOT IN (
SELECT id
FROM my_table_2)';
*/
 
$not_in_query = '%s NOT IN (
SELECT %s
FROM %s)';
 
$not_in_query = sprintf(
$not_in_query,
MyTable1Peer::ID,
MyTable2Peer::ID,
MyTable2Peer::TABLE_NAME
);
 
$c->add(MyTable1Peer::ID, $not_in_query, Criteria::CUSTOM);
 
$result = MyTable1Peer::doSelect($c);

You can add whatever other Criteria to the query as well. So far this is the only reliable way to run these sort of queries that I’ve found.

Here’s a quick script I created using linux’s wget to run another process in the background. You could use this to automatically upload something to another server, or just about anything that needs to happen after a user action.

Note: you must have exec enabled for this to work. This is a security risk, so make sure you know the potential damage that can be done by enabling exec, and by the script that you are running. Make absolutely sure to sanitize any input being transferred to the executed script.

In my case, I needed to initiate a file upload to a remote server after a certain action was taken. Because of the nature of the upload, it would have taken about 30 seconds before displaying any response to my user, which is an unacceptable delay.

First, make the script that needs to run in the background.

<?php
 
//ALWAYS USE THIS FOR UNATTENDED SCRIPTS, YOU DON'T WANT THEM RUNNING FOREVER
set_time_limit(60);
 
/*
SCRIPT THAT DOES SOMETHING YOU WANT TO RUN IN THE BACKGROUND
THIS SCRIPT CAN DO ANYTHING. IT IS A NORMAL PHP SCRIPT
HOWEVER, DO NOT MAKE A SCRIPT THAT WILL OUTPUT TO THE BROWSER
AS NOBODY WILL EVER SEE IT
*/
 
//YOU CAN ALSO USE sleep($seconds) TO RUN THIS AFTER A SPECIFIED AMOUNT OF TIME
sleep(30);
 
$output = 'SOME DATA THAT I GENERATED';
 
$ftp_user_name = 'user';
$ftp_user_pass = 'pass';
$ftp_server = 'ftp.someplace.com';
$ftp_dir='/this_folder/';
 
$destination_file = date('Y-m-d');
 
// connect, login, and transfer the file
$conn_id = @ftp_connect($ftp_server);
$login_result = @ftp_login($conn_id, $ftp_user_name, $ftp_user_pass); 
@ftp_put($conn_id, $destination_file.'.csv', $output);

Next, make the script that executes the background script.

<?php
 
//DO A BUNCH OF STUFF HERE...
 
//LOCATION OF THE PAGE YOU WANT TO EXECUTE IN THE BACKGROUND
$page_to_execute = 'http://www.mysite.com/background_script.php';
 
/*
COMMAND TO EXECUTE THE PAGE USING WGET
YOU CAN SEND GET VARIABLES USING THIS
BE ABSOLUTELY SURE TO PROTECT AGAINST INJECTION
*/
$command = 'wget -q '.$page_to_execute;
 
//ALTERNATELY TO WGET YOU COULD USE SOMETHING LIKE
//$command = "nohup /usr/local/bin/php -f ".$page_to_execute;
 
/*
NOW EXECUTE THE PAGE IN THE BACKGROUND
THIS WILL NOT RETURN ANY ERROR IF IT FAILS
YOU WILL NEED TO WATCH YOUR SERVER LOGS 
TO PROPERLY DEBUG
*/
 
@exec( "$command > /dev/null &", $arrOutput );

There you have it. This will run a script in the background (any web page that you specify). I do not use a local path to the file, because it will often break and can pose additional security risks. Using the above code, the server can only execute wget, and the actual page is parsed just like any other page on your website.

Again, make sure you understand the potential problems enabling exec can cause. There are also other ways of doing this such as running php from the exec command (path/to/php my_script). These can pose much greater security risks if they are not properly coded.

Lastly, this should be run on user or administrator initiated event, and not on events such as page views. This could spawn a huge number of processes if it is ever allowed to run based on every page view or something similar.