Using Zend Framework from the Command Line

Jed — Thu, 14 Aug 2008 19:29:32 +0000

I’ve been using the Zend Framework since roughly Beta 0.8 and have been thoroughly impressed with its evolution. Besides web sites I also like using php from the command line for things like cron jobs, shell scripts and the like. While it isn’t always the best suited language for such tasks, my familiarity with php often lets me get the job done faster than with another less familiar language. A few days ago I sat down and figured out how to get full access to the Zend Framework, including MVC, from the command line. Here’s how I did it…

This project is solely for cli use, it will contain a number of scripts running in the same “framework.” There is no web interface for this at all. I’m going to use a modified modular conventional file system to allow me to easily addon more scripts as I need them and still share the same infrastructure. My file system looks like this:

.-- project root
|-- application
|   |-- apis
|   |-- config
|   |-- layouts
|   |-- library
|   |   |-- Webf
|   |   `-- Zend
|   |-- models
|   |-- modules
|   |   |-- default
|   |   |   |-- config
|   |   |   |-- controllers
|   |   |   |-- models
|   |   |   `-- views
|   |   |       |-- filters
|   |   |       |-- helpers
|   |   |       |-- layouts
|   |   |       `-- scripts
|   |   `-- moduleX
|   |       |-- config
|   |       |-- controllers
|   |       |-- models
|   |       `-- views
|   |           |-- filters
|   |           |-- helpers
|   |           |-- layouts
|   |           `-- scripts
|   |-- tests
|   `bootstrap.php
|-- data
|   |-- cache
|   |-- indexes
|   |-- locales
|   |-- logs
|   |-- sessions
|   `-- uploads
|-- docs
|-- tmp
'zfcli.php

* Not all of these directory are needed for this application.

Typically you would have a public (htdocs, www, etc..) folder for the web root, however since this isn’t a web project I’m using zfcli.php as my “bootstrap” file, which is located in the project root. This file will glue Zend_Console_Getopt together with Zend_Controller_Request_Simple to get arguments from the command line into the request object. This will allow us to use ZF to its full potential from the command line.

Lets go ahead an create a simple IndexController and view so we have something to shoot for:

./application/modules/default/controllers/IndexController.php

class IndexController extends Zend_Controller_Action
{
    public function indexAction() {}
}

./application/modules/default/views/scripts/index/index.phtml

echo "default:index:index\n\n";

I’ll assume you understand the above, if not please check google for some getting started with Zend Framework tutorials.

Ok, we’re ready to get going. First up we need the bootstrap file:

./zfcli.php

error_reporting(E_ALL|E_STRICT);
ini_set('display_errors',true);
$pthRoot = dirname(__FILE__);
set_include_path('.' . PATH_SEPARATOR . $pthRoot . '/application/library'
    . PATH_SEPARATOR . $pthRoot . '/application/models'
    . PATH_SEPARATOR . get_include_path());
date_default_timezone_set('America/Chicago');

require_once('Zend/Loader.php');
Zend_Loader::registerAutoload();

try {
    $opts = new Zend_Console_Getopt(
        array(
            'help|h' => 'Displays usage information.',
            'action|a=s' => 'Action to perform in format of module.controller.action',
            'verbose|v' => 'Verbose messages will be dumped to the default output.',
            'development|d' => 'Enables development mode.',
        )
    );
    $opts->parse();
} catch (Zend_Console_Getopt_Exception $e) {
    exit($e->getMessage() ."\n\n". $e->getUsageMessage());
}

if(isset($opts->h)) {
    echo $opts->getUsageMessage();
    exit;
}

if(isset($opts->a)) {
    $reqRoute = array_reverse(explode('.',$opts->a));
    @list($action,$controller,$module) = $reqRoute;
    $request = new Zend_Controller_Request_Simple($action,$controller,$module);
    $front = Zend_Controller_Front::getInstance();

    $front->setRequest($request);
    $front->setRouter(new Webf_Controller_Router_Cli());

    $front->setResponse(new Zend_Controller_Response_Cli());

    $front->throwExceptions(true);
    $front->addModuleDirectory($pthRoot . '/application/modules/');

    $front->dispatch();
}

Here we have setup Zend_Console_Getopt with several possible parameters, -a being the one we will use to get the module.controller.action route for the MVC. After setting up Getopt, we parse() the command line options. Should an exception be encountered we want to catch it, display the error message and then show the usage message. Using -h will also show us the usage message.

Then last if{} block is where we get the unification going. By exploding on “.” we get an array of the module, controller and action, reversing the order makes it easier to deal with missing modules. Break this new array out into individual variables then plug them into Zend_Controller_Request_Simple. if you don’t use the @ in front of the list() statement you will get warnings when there is no module supplied, since I want to use default in these cases I just make it not report these errors, the router will automatically look for the “default” module.

Next we instantiate the front controller and tell it to use the request we just built. Next up we need a router that can be used in the CLI environment. Notice I’ve made a custom router, more on that in a bit. We also need to use the Zend_Controller_Response_Cli response object, tell it where the modules are, tell it to throw exceptions. Finally we dispatch the controller and our scripts are off and running.

./application/library/Webf/Controller/Router/Cli.php

require_once ('Zend/Controller/Router/Interface.php');
require_once ('Zend/Controller/Router/Abstract.php');

class Webf_Controller_Router_Cli extends Zend_Controller_Router_Abstract implements Zend_Controller_Router_Interface {

    public function assemble($userParams, $name = null, $reset = false, $encode = true) { }

    public function route(Zend_Controller_Request_Abstract $dispatcher) {}
}

The router is really very simple, though it took me a bit to figure this out. In order to ensure compatibility we need to extend the Router_Abstract and implement the Router_Interface. If, like me, you use a Zend IDE, like Zend Studio for Eclipse, and make use of the class wizards you can end up with a short list of methods to implement. In fact you only need two and they can be stubs.

That’s it, you’re in business. Try running php zfcli.php -a index.index and see what happens. You should see default:index:index just above your prompt

webFRACtor

Using Zend Framework from the Command Line