How Cache Cleanup Works

Here’s the source code in text format.

At the top of the script, you need to set two values – $dirName and $timeLimit.

$dirName should be a local path to the directory you want to scan for old files. $timeLimit should be the maximum allowable inactive time, in seconds.

The logic of the script is very straightforward. First, we scandir() to get an array of filenames in our cache directory.

Then, we loop through each fileName. If the file was last accessed before our timeLimit, we delete the file. If not, we leave the file alone.

If the script attempts to delete a file, it will output a success or failure message. Otherwise, there is no output.

How to Implement Cache Cleanup

First, set the configuration variables to your desired settings. I intentionally refrained from using any kind of input into the script for security reasons.

Next, decide how you want to run the script.

If your host allows you to run cron jobs, the logical choice would be to make this a cron job run every so often. Depending on how long you want the temporary files to remain on your server, I’d run the cron job once a day or so.

If your host doesn’t allow cron jobs, you could manually access the script each time you want to check for idle files and delete them. This isn’t a bad choice if you want to check once a week or so, but it is kind of annoying to do it every day.

You could also incorporate this into your caching script. Every time the script creates or accesses a cached file, it could call this script (as a function) and delete unused files. This may not be a desirable option for performance reasons if you have a lot of cached files, but it wouldn’t be bad for smaller cache directories.

Anyhow, I just wrote the script. You figure out how you want to implement it.

$dirName = 'cache';	// Path to the cache directory
$timeLimit = 300;	// Max time since a file has been accessed
			//   before it should be deleted
 
if (is_dir($dirName)) {
  $files = scandir($dirName);
}
 
foreach ($files as $file) {
  if ($file == '.' || $file == '..') {
    continue;
  }
 
  if (fileatime($dirName . '/' . $file) < time() - $timeLimit) {
    if (unlink($dirName . '/' . $file)) {
      echo "$file deleted successfully.";
    } else {
      echo "$file not deleted.";
    }
    echo '<br />';
  }
}

Or, take a look at my photography studio’s website. Along with photography, we offer a handful of design and printing services, mostly for models, actors, and fashion designers. Our newest offering is the design and printing of modeling/acting comp cards, which start at $60 for a set.

Most blogging platforms come with built-in support for RSS feeds. Why? It’s a great way for users to keep up to date on your new content. Instead of loading up a dozen favorite sites, they can look at one feed reader and then decide what to pursue further.

So what if you don’t use a blogging platform or CMS that creates a feed for you? You can create one yourself in PHP. It’s pretty simple.

Elements of an RSS 2.0 Feed

There are pretty strict standards about RSS feeds – intended to make it easier for readers to parse and display the information. Before we dive into building a feed, we should look at what it should contain. You can read the full spec at feedvalidator.

An RSS 2.0 Feed is a special type of XML file. The first things you’ll need in your file is an xml declaration, and an opening/closing RSS tag. Like this.

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  //  Feed elements here
</rss>

Inside the opening rss tag, you can also include any namespaces that you’ll be using. That’s a bit more than we need to worry about at the moment, though.

Inside the rss tag, you need to create a channel tag. This holds all of the individual articles as well as some basic information about the feed. You’re required to create a title, link, and description tag. You can add a lot of optional tags, of which the lastBuildDate tag would be most useful.

A basic channel declaration would look something like this.

<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com</link>
   <description>This is a feed of the latest articles at My Wonderful Blog.</title>
   <lastBuildDate>Thu, 14 Feb 2008 10:57:05 GMT</lastBuildDate>
 
   //  Include individual articles here
</channel>

Finally, you can include the individual articles inside of this channel tag. Each article is represented by an item tag and a series of optional tags. Some good tags to use for a basic feed would be title, link, description, and pubDate. Like this…

   <item>
      <title>My Latest Article</title>
      <link>http://mydomain.com/latestarticle.php</link>
      <description>This is the latest cool article at my wonderful blog.</description>
      <pubDate>Thu, 14 Feb 2008 10:57:05 GMT</pubDate>
   </item>

Using PHP to Create the RSS Feed

Now that we know what goes in to an RSS feed, we can worry about how to create one.

There are several approaches we can take here. We could have PHP dynamically output an RSS feed every time the file is accessed. We could create a SimpleXML object and write it to a file each time a new article is added. Or we could simply create a string and write it to an xml file.

We’ll take the third approach. This means we need to do three things.

• Fetch the data from the database
• Build the xml formatted string
• Write the xml data to a file

Fetch the Data from the Database

This will vary depending on the database type you’re using and how it’s set up. If you’ve gotten this far in creating a dynamic, PHP-driven site, I’m sure you can figure out how to fetch information for your own database.

For the purpose of this tutorial, we’ll fetch information from a mySQL database. The database will hold the title, link, description, and pubDate of each article.

$query = "SELECT title, link, description, pubDate FROM
   articles LIMIT 10";
$result = mysql_query($query);

Note: I only retrieved the last 10 entries. There is no strict limit to the number of entries an RSS 2.0 feed can have, but it’s polite to leave it small. If they want to read every article, they’ll come to your site.

Building the XML Formatted String

Now, we need to create a blank string, format it like an XML file, loop through the mySQL result array, and insert the data into the XML file.

First, we’ll add the xml declaration, the rss tag, the channel tag, and the channel info. Then we can loop through the result set and create one item tag for each article.

$xmlString = '<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com/</link>
   <description>Latest articles at My Wonderful Blog.</description>
   <lastBuildDate>' . date("D, d M Y H:i:s e") . '</lastBuildDate>
 
';
 
while ($row = mysql_fetch_array($result)) {
$xmlString .= '   <item>
      <title>' . $row['title'] . '</title>
      <link>' . $row['link'] . '</link>
      <description>' . $row['description'] . '</description>
      <pubDate>' . date("D, d M Y H:i:s e", $row['pubDate'] . '</pubDate>
   </item>
';
}
 
$xmlString .= '</channel>
</rss>';

Most of that should be self-explanatory. Where I added a newline before ending the string, I was simply adding white space to make the source code more readable. This isn’t necessary – but I like neat, readable source code.

$xmlString is being created in the beginning. Then, the additional strings are appended to it with the .= operator.

The one important thing to note here is date("D, d M Y H:i:s e"). This is PHP’s function to create a formatted date. The characters inside the string determine how the timestamp is formatted.

This format is the standard required by RSS 2.0 feeds. You could simply copy and paste this string to format your dates. “D, d M Y” creates something like “Thu, 14 Feb 2008.” “H:i:s” creates the time as “18:23:30.” “e” is a representation of the timezone – which should be GMT.

Write the String to an XML File

Finally, we need to write this string to an xml file. For simplicity’s sake, we’ll call this “feed.xml” and place it in the same directory as our script.

You could use a few functions to do the file-writing. In this case, file_put_contents would be simplest – all we need to do is dump the contents of the string into a file and overwrite any previous contents.

$filename = "feed.xml";
file_put_contents($filename, $xmlString);

Now you just need to incorporate this into your existing site. You could make this a standalone script and access it every time you add new content to your site.

Or, if you’re using some kind of home-brewed CMS, you could wrap this in a function and call it right after you save the content of a new article.

Besides creating a custom feed for your own website, there are some other uses for this. You could use it to create a feed of articles from diverse sources around the internet.

If you write at a variety of sites – like Helium, Associated Content, and Xomba – you can use this to create a unified feed. Or, you could create a feed of only select articles from one of those sources. You could also create a feed of simple data – not articles – like quotes, jokes, tips, etc.