In this new post to his blog Adam Jensen looks at creating cron jobs with the help of the Zend Framework without having to load up the entire MVC architecture to get there.

So, we're going to need a new application bootstrap and entry point, one that eschews the MVC routing and dispatch process in favor of something simpler. Essentially, all we'll need is to be able to run an arbitrary collection of cron "task plugins," the list of which can be configured in plain text via any of the various Zend_Config formats (e.g., the default application.ini file).

He starts with the base functionality, a task plugin interface that allows you to set up a "framework" to run the tasks in. He also creates a simple cron service that handles the execution of the tasks (this is the main executable) and includes the code for creating the bootstrap for the Zend Framework to understand how to use it all. Then to create a new task, all you have to do is extend the CronInterface.

In a recent post to his blog Ian Christian has written up an example of how to send a multipart email from a Task inside your Symfony application.

I recently needed to send the result of an action in symfony via email daily. E-mail has changed slightly in symfony 1.3/1.4 - here's how I did it. I really don't like my solution at all, the use of get_partial() from within a Task seems very wrong to me - but I'm in a rush so it will do for now, I'd love to hear feedback.

His class extends the sfBaseTask and sets up an execute method that builds a database connection, fetches a few rows and, with a newly created mailer instance, sends the information using the get_partial method to define both HTML and text content parts of the email.

Padraic Brady has started up a new series of posts to his blog on the topic of asynchronous processing with PHP.

Imagine a world where clients will give up on receiving responses from your application in mere seconds, where failed emails will give rise to complaints and lost business, where there exist tasks that must be performed regularly regardless of how many requests your application receives. This is not a fantasy world, it's reality. [...] Asynchronous processing is a method of performing tasks outside the loop of the current request. Basically, you offload the task to another process, leaving the process serving the request free to respond quickly and without delay.

He talks about some of the problems that asynchronous processing solves (like tasks that must be completed despite errors) and starts to outline a simple processing structure with child processes and task handling.

In this new entry to his blog Raphael Stolt shows how to combine TextMate's snippets (handy bits that can be inserted/executed over and over) and Phing to run custom tasks.

As a reader of this blog you might have noticed that from time to time I like to utilize Phing's ability to write custom tasks. [...] This is actually a bad habit/practice I'm aware of and to improve my future endeavours in custom Phing task development, I bended TextMate's snippet feature to my needs.

He includes the snippet code example so you can copy and paste it over if you'd like to work it into your routine. This can be dropped directly into the Bundles editor and have a tab trigger applied to make using it even easier.

Raphael Stolt has another post dealing with the Phing (PHP-based) build tool. This time he talks about making ad hoc tasks inside of your build scripts.

Sometimes there are build scenarios where you'll badly need a functionality, like adding a MD5 checksum file to a given project, that isn't provided neither by the available Phing core nor the optional tasks. [...] The following post will try to outline how to define and use these inline tasks, by sketching an ad hoc task that enables the build orchestra to clone Git repositories from GitHub during a hypothetical workbench setup.

He creates an example task - running a "clone" command via github - complete with the code for both sides of the feature; the PHP code to create the task and how to use it in your build file.

Jakob Westhoff has posted about a new scheduler utility that he an Kore Nordmann worked up to fill a need they had for a "recurring management system" for some of their projects.

Periodic is a fully unit tested PHP based task runner. It is supposed to deliver a basic implementation for managing all kinds of recurring tasks and events inside your web application. It has been designed with having all kinds of different web hosting environments in mind. It is capable of running on most shared hosting systems as well as root servers.

They even went so far as to write up a design document for the implementation. You can grab the latest version of the script off of their subversion server: svn://arbitracker.org/arbit/projects/periodic

Chris Hartjes has a new post to his blog today focusing on using a bit of the CakePHP framework's functionality from the command line.

I'm porting a spaghetti-PHP application over to using CakePHP I am moving their existing authorization system over to using Cake's Auth component. Of course, they are storing all their passwords in plaintext in the user account table, so I needed an easy way to convert all the existing passwords over to be encrypted using the same hash that Auth would use.

With the help of the shells and tasks that the framework makes availiable, he's able to make a simple 24 line class (EncryptPasswordShell) that extends the Shell object and loops through the data to push it back into the database in the correct password format.

On the Symfony blog today, Romain Dorgueil shows how to create tasks to help automate things in your application like database updates, console scripts or other "repetitive maintenance tasks".

Symfony 1.1 extends symfony 1.0 pake tasks to create a powerful and uniform command line utility for your projects, fully integrated with the symfony Command Line Interface (CLI).

This means that is has the abilities to automatically support a "help" parameter, to grab a current task list the app is using, correct handling of the input parameters, set up a good environment and make sure that the source is readable. The post shows how to create a new task for your application - their examples are a "doNothingTask" that, well, does a lot of nothing and the typical "doHelloWorldTask" that just echoes.

They show how to define the task (including a namespace for it) and how to run it, outputing the results of the execute() method ("I did nothing successfully!" in the first case and a string of passed in parameters in the second.

On the Developer Tutorials blog, Akash Mehta has posted an introduction to working with command-line PHP scripts and cron jobs for site automation.

Scheduled tasks are a fairly common feature in modern web applications. From cleaning out caches every 24 hours to checking subscription periods and even generating reports, more web applications live by the clock than ever before. But how do we schedule the execution of a PHP script on the server side?

He shows the two key things to getting it working - an example of a command-line call to a PHP script (executed through his /usr/bin/php) and an example of a line from a crontab showing how to execute the script at midnight every day.

On the Tiger Heron blog, there's a continuation of the series that Tony Freixas has been writing to following the beginning steps of working with PHP. First there was the download/install, then setting up a development environment. This time, he actually gets around to writing a bit of basic code.

Specifically, I will describe how I boot my PHP scripts and why I boot them the way I do. Part 1 shows how my requirements for code portability and maintainability influence the boot process. Part 2 will go into more detail about the specific steps executed by the boot code.

His basic task for the first example is to make a templating sort of system, calling a Navigation class to output links in list items. He outlines the goals of the project, what he's found for his current solution and some alternatives he's discovered along the way.