OK, a lot of you guys have noticed that I’ve been uncharacteristically silent for the past month or so. Now I can finally start talking about it- the Simple Cloud API has launched at http://www.simplecloud.org.

This API gives PHP developers one interface to code to for what we call ‘cloud application services’. These are runtime application services like nosql databases, storage, and simple queues. These services make it easier to write ‘cloud native’ applications that can take full advantage of the cloud’s promises of scalability and high-availability. I’ve found myself saying this a lot lately: “What’s the point of an infinitely scaling compute cloud when your applications can’t scale with it?”

We expect to be adding more of these services to the API as vendors roll them out. Possible services include email, session management, single sign on, etc. I can go on and on, but why don’t we let the vendors figure out what their customers need and vote with adoption? In any case, once such a service hits critical mass, the Simple Cloud API will have you covered.

The Simple Cloud API will be delivered as a new Zend Framework component called Zend_Cloud. The code will be available *very* soon.

So, why didn’t we do elastic compute cloud services in this first version of the API? That deserves a blog post of its own.

,Wil

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

So in my latest project I’ve been using Zend_Db_Table which is really nice for interfacing with a table, however it lends itself for a simple table structure which maps perfectly with your php/application model. I, however, do not have that luxury as I usually normalize my table structure. So one night, around 2am, I wrote an abstract class to allow me with minimum code do the following:

$table1->joinedTable->joinedTableField

Now, I am sure the code I wrote to do this is coupled, inefficient, etc. So as always, feel free to openly torment it

First Things First
Let me lay out my file structure that I use. The file structure is not dependent on the class I wrote, but I use autoload so it will make sense why I name what I name what:

+ app
  + Models
    + DB
– AbstractModel.php (this is my class)

So I basically added another layer to the Model. In /app/Models/DB I put all my simple Zend_Db_Table classes that represent a table in my database. Then I put all my PHP Model Objects in the /app/Models directory. Before I get to far ahead of myself, it’s always best for me to learn by a live working example so without further adue:

The Example

I have about 16 tables so far in this project ( mid build ) but let’s take a table that joins a lot of other tables. That table is called establishments. Here is the DDL for the table establishments:

CREATE TABLE `establishments` (
`id` bigint(20) unsigned zerofill NOT NULL auto_increment,
`name` varchar(255) default NULL,
`categoryID` mediumint(8) unsigned default NULL,
`longitude` double default NULL,
`lattitude` double default NULL,
`address` varchar(255) default NULL,
`cityID` tinyint(3) unsigned default NULL,
`stateID` int(10) unsigned default NULL,
`zip` varchar(6) default NULL,
`website` varchar(255) default NULL,
`mainPicID` int(10) unsigned default NULL,
`description` text,
`dressID` int(11) default NULL,
`vallet` tinyint(1) default NULL,
`isActive` tinyint(1) unsigned NOT NULL,
PRIMARY KEY  (`id`),
UNIQUE KEY `name` USING BTREE (`name`,`categoryID`),
UNIQUE KEY `address` (`longitude`,`lattitude`)
) ENGINE=MyISAM AUTO_INCREMENT=24 DEFAULT CHARSET=utf8

The columns to note are:

• categoryID: categories Table ( id, name, isActive )
• cityID: cities Table ( id, name, lattitude, longitude, isActive )
• stateID: states Table ( id, name, longitude, lattitude, isActive )
• mainPicID: photos Table ( id, categoryID, entityID, userID, location, description, timestamp, isActive )
• dressID: dress Table ( id, name, description, isActive

The Objective
The goal is to be able to do the following very easily:

$establishment->name //returns establishments.name
$establishment->category->name //returns categories.name mapped to categoryID
$establishment->city->name //returns cities.name mapped to cityID
$establishment->state->name //returns states.name mapped to sateID
$establishment->photo->location // returns photos.location mapped to mainPicID
$establishment->dress->name // returns dress.name mapped to dressID

As you can see this gives us two things, easily mapping our normalized table out & being able to keep naming in our application layer different then the naming in our database (e.g. as a property that represents a table is usually singular tense and the table is plural). Well, let’s as always, work backwards. We need to load $establishments:

//I actually do not do this, I use a factory! But here you go anyways
$establishments = new Models_Establishment();

//Grab the Active Record Where the Name Matches the var $estabNam
$establishment = $establishments->find('name', $estabName);

The Establishments Class
Now we need to actually have our Models_Establishment class. Simply save the following in /app/Models/:

class Models_Establishment extends Models_AbstractModel {
  protected $_map = array(
    'self'=>'Models_DB_Establishment',
    'category'=>array('col'=>'categoryID', 'class'=>'Models_DB_Category'),
    'city'=>array('col'=>'cityID', 'class'=>'Models_DB_City'),
    'state'=>array('col'=>'stateID', 'class'=>'Models_DB_State'),
    'photo'=>array('col'=>'mainPicID', 'class'=>'Models_DB_Photo'),
    'dress'=>array('col'=>'dressID', 'class'=>'Models_DB_Dress')
  );
}

If you notice the first thing this class does is extend the abstract model class which I haven’t gotten into yet. The only other thing in this class is the $_map array which simply maps your object. The ’self’ index maps the current object to it’s base/core Zend_Db_Table file as you see here ‘Models_DB_Establishment’ which exist in /app/Models/Db/Establishment.php and it looks like:

class Models_DB_Establishment extends Zend_Db_Table_Abstract{
  public $_name = 'spottedhere.establishments';
  protected $_primary = 'id';
}

Nothing fancy there. Then the other indexes are category, city, state, photo, and dress. These all map what the ID is in the current object (categoryID, cityID, etc.) and which DB file to use. All these DB files exist in /app/Models/DB and here is what /app/Models/DB/Category.php looks like:

class Models_DB_Category extends Zend_Db_Table_Abstract{
  public $_name = 'spottedhere.categories';
  protected $_primary = 'id';
}

As you see they are all very similar. So for the most part all you have to do is have a /app/Models/DB/ table for each table you have and each one just specifying the name of the table and the primary key. Now all you need is the abstract class which exist in /app/Modles/AbstractModel.php and it looks like:

abstract class Models_AbstractModel {

  protected $id;
  protected $data;
  protected $selfObject;
  protected $_complexFields;
  protected $_map;
  static protected $pk = 'ID';

  public function __construct() {
    $this->selfObject= new $this->_map['self']();
  }

  public function __get($what) {
    if(is_array($this->_map)) {
      if(array_key_exists($what, $this->_map)) {
        try {
          return $this->data->$what;
        } catch (Exception $e) {
          return false;
        }
      }
    }
    if(is_array($this->_complexFields)) {
      if(array_key_exists($what, $this->_complexFields)) {
        $o;
        foreach($this->_complexFields[$what]['fields'] as $field) {
          $o .= $this->data->self->$field.$this->_complexFields[$what]['seperator'];
        }
        return $o;
      }
    }
    try {
      return $this->data->self->$what;
    } catch (Exception $e) {
      return false;
    }
  }

  protected function build() {
    if(is_numeric($this->id)) {
      $this->data->self = $this->selfObject->find($this->id)->current();
      if(is_array($this->_map)) {
        foreach($this->_map as $field=>$properties) {
          if(is_array($properties)) {
            $s = $properties['class'];
            $i = new $s();
            if($properties['col']) {
              //dependent table
              $this->data->$field = $i->find($this->data->self->{$properties['col']})->current();
            } else {
              //not dependent table
              $this->data->$field = Models_Loader::get('UserAccount')->find($properties['fk'], $this->id);
            }
          }
        }
      }
    }
  }

  public function find($field, $value) {
    $record = new $this->_map['self']();
    $table = $record->_name;
    $dbObj = Zend_Registry::get('db');
    if(!is_array($value)) {
      $sql = 'SELECT '. self::$pk .' FROM '. $table ." WHERE {$field} = \"{$value}\" LIMIT 1";
      $id = $dbObj->fetchOne($sql);
      if(is_numeric($id)) {
        $this->id = $id;
        $this->build();
        return $this;
      } else {
        return false;
      }
    } else {
      $sql = 'SELECT '. self::$pk .' FROM '. $table ." WHERE {$field} IN (". implode(',',$value) .')';
      return $dbObj->fetchAll($sql);
    }
  }

  public function insert($data) {
    return $this->selfObject->insert($data);
  }

  public function toArray() {
    $d = array();
    foreach($this->data as $i=>$v) {
      if(get_class($v) == 'Zend_Db_Table_Row') {
        $d[$i] = $v->toArray();
      }
    }
    return $d;
  }

}

Anyways, this was my quick solution. As always, looking forward to your feedback!

So my last post I showed a simple little form I had created for letting people create records. Let’s talk about something a little more useful this time. It is very common to want to include a login form, or if they have logged in, some user control bar on every page in your site/application. Let me emphasize, I am by no stretch of the imagination the holy grail of how to do stuff, and would be safe to say that since I am suggesting this approach it is, not the best way. However, it has served me well in the few applications I have made with Zend Framework, thus I will share.

** Update **

File Structure
Below is how I structured my files:
+ Project

+ app
  + forms
  + layouts
    + helpers (If you put your view helpers here, register this dir as a view helper dir)
    + scripts
  + lib
  + models
  + modules
    + default
      + controllers
      + views
        + scripts
        + helpers (default location Zend FW looks for View Helpers when default         module invoked)
+ config
+ misc
+ www

Invoking Code
Since, we will be putting this on every page it makes sense to put the invoking code in Zend_Layout. If, you aren’t using Zend_Layout.. I highly suggest you start migrating it into your code. Zend Layout basically allows you to have a “layout” for different pages, which renderes “templates” that correspond to the actions. (That’s a nutshell version) So in my layout I simply put:

echo $this->userControlBar();

This will invoke Zend_View to look for the view helper: UserControlBar. Now it’s good to know a couple of things here, each page request will only have one Zend_View object. So, Zend_Layout, doesn’t have it’s own view object, rather the Zend_View is injected into the Zend_Layout. This means, that the view helper User Control Bar, has to be registered with the view for that action. I may be over-complicating the issue, just be sure that you could call $this->userControlBar() in the template scripts corresponding to all the actions.

The View Helper
Now, we need the View Helper. In the helper, we will call default View Helpers that come with Zend_View but in order to do that we have to register the View object with the View Helper. To do that we simply add the following method to our View Helper:

    public function setView($view) {
        $this->_view = $view;
    }

Then the next method we make is the actual View Helper:

    public function userControlBar() { echo 'hi'; }

This should return ‘hi’ in the Layout. Now we simply, need to make it work. We want to first determine if the user has been authenticated which can be done with:

    Zend_Auth::getInstance()->hasIdentity()

This, as expected, will return true or false. So let’s put it in a little if statement:

    if(Zend_Auth::getInstance()->hasIdentity()) {
      //user is logged in
    } else {
      //user is not logged in
    }

Now let’s just say we want 3 controls, and we want the html to be:

• Control One
• Control Two
• Control Three

We can do this very easily with two default View Helpers: (htmlList, and url). First thing we need to do is build an array of the links we want to show. You -could- abstract this out another level it warranted it, but we have a simple app, so we can just hard code this array (note how we are utilizing the registered view):

   $links = array();
   $links[] = '<a href="' . $this->_view->url(array('controller'=>'action1'),
 '', true) . ">Control One';
   $links[] = '<a href="' . $this->_view->url(array('controller'=>'action2'),
'', true) . ">Control Two';
   $links[] = '<a href="' . $this->_view->url(array('controller'=>'action3',
'param'=>'value'), '', true) . ">Control Three';

Then we can register the $links array with the View Helper htmlList:

   //Should change name most likely 
   $linkList = $this->_view->htmlList($links, false, array('id'=>'userControl') , false);

The above code will generate the HTML we need. So our ViewHelper now looks like:

   if(Zend_Auth::getInstance()->hasIdentity()) {
      //user is logged in
      $links = array();
      $links[] = '<a href="' . $this->_view->url(array('controller'=>'action1'), '', true)
 . ">Control One';
      $links[] = '<a href="' . $this->_view->url(array('controller'=>'action2'), '', true)
 . ">Control Two';
      $links[] = '<a href="' . $this->_view->url(array('controller'=>'action3',
'param'=>'value'), '', true) . ">Control Three';
      //Should change name most likely 
      $linkList = $this->_view->htmlList($links, false, array('id'=>'userControl') , false);
      return $linkList;
   } else {
      //user is not logged in
   }

Now that’s all good and dandy, but what if they aren’t logged in? Well, we have two options here, we can just write the Form ourself or use Zend_Form. I personally love Zend_Form. However for sake or this tutorial we will just generate the html ourself. You can simply put the html of the form in a variable and return it for now, that way if you want to do it the right way later, and use Zend_Form, it’s really easy

      ...
   } else {
       $form = '... html for login form here ...';
      return $form;
   }

That’s it. Now in all of our pages we will either have a login form or a control bar. We’ve used the View Helpers, Zend_Layout, *hopefully Zend_Form*, wrote our own Helper, and the gorgeous part is we haven’t touched the “Application” code inside the Modules/Defaults/Controllers. We simply listen to Zend_Auth and return whatever.

Hope this helps, and I’d love to see how I could improve my technique.

 Given the zend_controller naming changes in zend framework 1.5 for controllers and actions and the corresponding url, I’m trying to figure out a recommended naming scheme that I can use for zf 1.5 and onwards.  This forum post helped a lot: http://www.nabble.com/AW%3A-Normalizing-action-function-names-p16110540.html but it does not mention multi-word controllers and file and directory names.  Here’s what I could figure out.   Comments?

• URL:
  • domain.com/controller-name/action-name
    • note the use of dash (-) in the url.
• Controller File:
  • Controller File name / Class name:
    • Filename and class name are the same.
    • MixedCase
    • eg: file RoadMapController.php contains class RoadMapController for url domain.com/road-map
    • Zf 1.5 docs explicitly recommends caps for first character (not sure what “Title-cases” refers to in the zf docs).  Implicitly, it seems to suggest MixedCase if I want dashes in the url.
    • Need separators:
      • No Underscore ( _ ) since it will break mvc mapping so can’t use (might imply a sub-directory)
      • Dash ( – ) is not allowed in class name since it’s a minus sign.
      • Need casing to make it readable since I can’t use separators
  • View Action method name inside controller code
    • Use camelCase
    • Eg: componentsForHighLevelAction for domain.com/road-map/components-for-high-level
    • Mixed case does not work.  View action method must be camelCase.  This was a changed in ZF 1.5. 
    • No Underscore ( _ ) since it will break mvc mapping so can’t use.
• View File and directory:
  • Controller directory name that holds the view script files:
    • All lower case with dashes between words. 
    • Matches controller part of url
  • View file name:
    • All lower case with dashes between words. 
    • Matches view part of url
    • URL Underscore ( _ ) gets mapped to filename dash ( – )
  • Eg: my_file_system/road-map/components-for-high-level.phtml
• Resources and notes:
  • This naming scheme is pretty complicated.  It sure would be nice to have a complete example explicitly documented in the zend_controller reference guide.  I’m really looking for the zend framework recommendation on setting this up such that it covers the common cases, enables readable (word separated) URLs, and will be stable for future releases.  Well, this is my attempt at documenting it.
  • Good reference for zf 1.5: http://www.nabble.com/AW%3A-Normalizing-action-function-names-p16110540.html
    • What was the thread in the mailing list before?  Is it: http://www.nabble.com/correct-controller-php-file-name-td14424663.html#a14425880
    • Or could be http://www.nabble.com/Need-help-using-dashes-in-action-names-td13348011.html#a13349348
    • This is interesting in the context of naming: underscore is new directory: http://www.nabble.com/underscore-in-URL-td15406669.html#a15411590
  • From zf 1.5 manual:
    • Zend_Controller’s dispatcher then takes the controller value and maps it to a class. By default, it Title-cases the controller name and appends the word Controller. Thus, in our example above, the controller roadmap is mapped to the class RoadmapController.
    • Similarly, the action value is mapped to a method of the controller class. By default, the value is lower-cased, and the word Action is appended. Thus, in our example above, the action components becomes componentsAction, and the final method called is RoadmapController::componentsAction().
    • From intro http://framework.zend.com/manual/en/zend.controller.html

see this ZF forum post for updated information: http://www.nabble.com/Naming-Recommendation-for-Controllers%2C-Actions%2C-and-URLs-using-zend_controller-td16362913.html