Unfortunately this is not possible. We do
not offer or support any type of email to script functionality on our
servers.

And this pretty much backed up all the searches I had been doing on line in regards to Dreamhost and using procmail.

Now, where they may not support people doing this, it is my pleasure to tell you that it is possible! And here’s how you do it…

The first think you have to do is set up the email address that you want to have processed – this can be done from the control panel under ‘Mail > Manage email > Create new email address‘. Let’s pretend that you set one up called process@yourdomain.com.

Now you have your email user set up you need to create a shell account user – one that can log in via SSH. This can be done from ‘Users > Manage users > Add a new user‘. It’s important that you select the ‘Shell: allows SFTP/FTP plus shell access’ option. (You may want to use one of your existing shell users, of course, but I personally set one up just for the purpose as Dreamhost doesn’t limit you on the number of users you can have.)

Now that you have the email address and shell user account set up, you now need to forward whatever goes to that address to the shell account. This is done with a filter, which can be modified in ‘Mail > Message filters‘. You can have multiple filters on the same address, so you may do some additional processing, but the essential filter to have for the script parsing is to have the email sent to the shell user. So enter your filter string (I made mine so that the ‘To’ contains ‘*’ – ie, everything, but you may only want it matching something particular for processing by the script), and select the ‘Forward to shell account’ option with the appropriate user selected. Then select the option what to do when the filter matches – ‘execute and stop’ or ‘execute and continue’. I chose the former because I had only the one filter, but you will want it to continue if you have more (or stop is this is the last of multiple filters).

OK, we’re about half way there…

Now you want to log in to the shell account and create a few files. The first file has the filename .forward.postfix and has the contents:

"|/usr/bin/procmail -t"

(Yes, you need the quotes!)

The next file is your procmail rule, and that’s in a file that’s called .procmailrc. It’s possible to do a lot of things with procmail and I’m going to explain none of them here! At the end of this post will be some links about procmail for you to check out and learn from. Instead, I’ll just show you what I have and you can go from there.

DEFAULT=$HOME/Maildir/
MAILDIR=$HOME/Maildir
PMDIR=$HOME/.procmail
LOGFILE=$PMDIR/log.`date +%y-%m-%d`
SHELL=/bin/sh

:0
|`/usr/local/php53/bin/php /home/youruser/yourscript.php`

The first four lines just set up various things; the location of your mail directory, the log file name, and so on. If the directory .procmail doesn’t exist in your root directory then you may want to create it.

The last two lines are the procmail recipe. Often here you will see three lines – the :0 to start a rule (sometimes with a lock file – again, follow the procmail links for info) then a filter, such a From.*person@domain and then the ‘what to do if this matches’ part. I skipped the filter because I wanted to capture anything that came in to my email address.

The next line is really the important one. You need the pipe (the ‘|’) to pipe the content of the email to a script execute via a shell command. And that’s crucial here – you need to wrap your command up in backticks (`) for it to work – I had no luck without those.

You’ll notice here that I’m using the PHP binary specifically at /usr/local/php53/bin/php – this is because I wanted to use PHP 5.3.

And there you have it – send an email to process@yourdomain.com and the script (in the example above, yourscript.php) will be able to read in the email via stdin and do something with it.

By the way, the PHP code to get the email in to a variable is:

$rawEmail = '';
if (($fp = fopen('php://stdin', 'r')) !== false) {
    while (!feof($fp)) {
        $rawEmail .= fread($fp, 1024);
    }
    fclose($fp);
}

You can then parse it for multiparts and so on. If you’re like me and want a really easy way to do that, just use Zend_Mail_Message:

$email = new Zend_Mail_Message(array(
    'raw' => $rawEmail
));

Procmail links

All of these are external links and I cannot vouch for the quality of any of them or how much you’ll learn from reading them. However, as one if procmail’s very own homepage, you can’t really go wrong!

• Procmail homepage
• Procmail guide
• Quick reference guide
• Mail filtering with Procmail

    background: #9880cc; /* Old browsers */
    background: -moz-linear-gradient(top, #9880cc 0%, #bab3cc 93%); /* FF3.6+ */
    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#9880cc), color-stop(93%,#bab3cc)); /* Chrome,Safari4+ */
    background: -webkit-linear-gradient(top, #9880cc 0%,#bab3cc 93%); /* Chrome10+,Safari5.1+ */
    background: -o-linear-gradient(top, #9880cc 0%,#bab3cc 93%); /* Opera11.10+ */
    background: -ms-linear-gradient(top, #9880cc 0%,#bab3cc 93%); /* IE10+ */
    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#9880CC', endColorstr='#BAB3CC',GradientType=0 ); /* IE6-9 */
    background: linear-gradient(top, #9880cc 0%,#bab3cc 93%); /* W3C */

Once upon a time, not that long ago, the trend setters/leaders of the web development community would have lynched you if you so much as dared to use a proprietary tag, be it in the css or the html. Now they’re actively encouraging the above kind of usage?! It’s ridiculous! Firefox, Chrome, Safari, IE and Opera all require different proprietary rules, and then you have the W3C recommended way and then the fallback for older browsers.

A Transform in CSS3 is just as bad:

-moz-transform: scale(0.8) rotate(deg) translate(px, px) skew(deg, deg);
-webkit-transform: scale(0.8) rotate(deg) translate(px, px) skew(deg, deg);
-o-transform: scale(0.8) rotate(deg) translate(px, px) skew(deg, deg);
-ms-transform: scale(0.8) rotate(deg) translate(px, px) skew(deg, deg);
transform: scale(0.8) rotate(deg) translate(px, px) skew(deg, deg);

And this time it’s not the rule value that’s different for each, it’s the rule name!

I think HTML5 (well, XHTML5 for me – I do love a properly closed tag!) and CSS3 are great, don’t get me wrong, and I think we’ve already seen a lot of examples of wonderful sites and demos created using them. But surely how it’s getting there and the asinine number of rules we have to put in for each browser is a major step backwards in what people were trying to achieve only a few years ago? (Ie, a nice compliant standard way of doing things.)

Incidentally; there are a couple great sites that help out doing fancy new CSS3 stuff:

The Ultimate CSS Gradient Generator
CSS3 Generator

Using sites like those can save a bit of sanity.

    /**
     * Sort an array of objects.
     *
     * You can pass in one or more properties on which to sort.  If a
     * string is supplied as the sole property, or if you specify a
     * property without a sort order then the sorting will be ascending.
     *
     * If the key of an array is an array, then it will sorted down to that
     * level of node.
     *
     * Example usages:
     *
     * osort($items, 'size');
     * osort($items, array('size', array('time' => SORT_DESC, 'user' => SORT_ASC));
     * osort($items, array('size', array('user', 'forname'))
     *
     * @param array $array
     * @param string|array $properties
     */
    public static function osort(&$array, $properties)
    {
        if (is_string($properties)) {
            $properties = array($properties => SORT_ASC);
        }
        uasort($array, function($a, $b) use ($properties) {
            foreach($properties as $k => $v) {
                if (is_int($k)) {
                    $k = $v;
                    $v = SORT_ASC;
                }
                $collapse = function($node, $props) {
                    if (is_array($props)) {
                        foreach ($props as $prop) {
                            $node = (!isset($node->$prop)) ? null : $node->$prop;
                        }
                        return $node;
                    } else {
                        return (!isset($node->$props)) ? null : $node->$props;
                    }
                };
                $aProp = $collapse($a, $k);
                $bProp = $collapse($b, $k);
                if ($aProp != $bProp) {
                    return ($v == SORT_ASC)
                        ? strnatcasecmp($aProp, $bProp)
                        : strnatcasecmp($bProp, $aProp);
                }
            }
            return 0;
        });
    }

Now a few cools things about the function:

1. It uses anonymous/lambda functions (or closures, whatever your prefer to call them), and that’s just plain fun
2. You can sort on more than one property and because the sorting is recursive, it’ll sort the second property within the confines of the first, the third within the confines of the second, and so on. Think sorting in SQL
3. You can sort in ascending or descending order for any of the properties
4. It retains key associations so you could use this on an associative array of objects
5. If the parameter you want to sort on is an array itself then you can use any value (by specifying it’s key) in that array as the sorting value

<?php echo $this->escape($this->var); ?>
<?= $this->escape($this->var); ?>

You could simply do:

<?=~ $this->var; ?>

That’s a lot simpler, isn’t it?

To do this, we need to do two things; 1) extend the stream class and 2) make sure we register it before Zend Framework registers Zend_View_Stream.

<?php

class My_Stream extends Zend_View_Stream
{
    /**
     * Opens the script file and converts markup.
     */
    public function stream_open($path, $mode, $options, &$opened_path)
    {
        // get the view script source
        $path        = str_replace('zend.view://', '', $path);
        $this->_data = file_get_contents($path);

        /**
         * If reading the file failed, update our local stat store
         * to reflect the real stat of the file, then return on failure
         */
        if ($this->_data === false) {
            $this->_stat = stat($path);
            return false;
        }

        /**
         * Convert <?= ?> to long-form <?php echo ?> and <? ?> to <?php ?>
         *
         */
        $this->_data = preg_replace(
            '/\<\?\=~ (.*?);? \?>/',
            '<?php echo $this->escape($1); ?>',
            $this->_data
        );
        $this->_data = preg_replace(
            '/\<\?\=/',
            '<?php echo ',
            $this->_data
        );
        $this->_data = preg_replace(
            '/<\?(?!xml|php)/s',
            '<?php ',
            $this->_data
        );

        /**
         * file_get_contents() won't update PHP's stat cache, so we grab a stat
         * of the file to prevent additional reads should the script be
         * requested again, which will make include() happy.
         */
        $this->_stat = stat($path);

        return true;
    }
}

The observant of you will notice that the above is almost exactly the same as Zend_View_Stream::stream_open(), but with this bit of code added to it:

        $this->_data = preg_replace(
            '/\<\?\=~ (.*?);? \?>/',
            '<?php echo $this->escape($1); ?>',
            $this->_data
        );

So if you don’t like using ~ to do the escape this is where you’d change it.

Now all you have to do is register your stream before Zend Framework does. You could do this in your bootstrap file, your application class, or whereever it makes sense for your applicaiton. Basically, you’d just be dropping in a line like this:

stream_register_wrapper('zend.view', 'My_Stream');

Hopefully that gives you some ideas on extending the stream wrapper even more!

101010 in binary is 42 which is, as we all know, the answer to life the universe and everything in it.

Usually I’m a total wallflower at conferences, gravitating to only the people I know. This time round I’m trying to change that and speak to people, ask speakers questions, and all that.

Right now, though, I’m enjoying dinner.

The agony of choice, eh?

One thing that irked me, though, was that now my Zend Studio’s version of Zend Framework was different.  That doesn’t seem like a big problem, but I use the include path for my projects and always have ZF on there, which allows me to take advantage of the auto complete and so on.

My first thought was to use a symbolic link to point form the Studio’s folder to the Server CE folder…  But wait, I’m using Windows 7 – surely something as handy as a symbolic link can only be used on Linux machines?  I can understand why you’d think that, but did you know that you can create symlinks on Windows as of Vista?  Oh yes, you read correctly, my friend!  The command to do that is:

mklink /D \Path\To\SymLink \Path\To\Original

So for me, it was a case of doing:

mklink /D "ZendFramework-1" "C:\Program Files (x86)\Zend\ZendServer\share\ZendFramework"

from within my Zend Studio folder, which happened to be:

C:\Program Files (x86)\Zend\Zend Studio - 7.1.1\plugins\org.zend.php.framework.resource_7.2.0.v20100324-1300\resources

I rebuilt my projects and lo-and-behold, a new version of ZF for my projects, and one that’ll always match with what Zend Server CE thinks I’m using.

Now, the GD02 case doesn’t have a few things that the Fusion does.  It doesn’t have a display on the front.  To be honest, I’m coming around to the idea of that actually being a really good thing.  Do I really want to have a really bright (from what I’ve read) display on the front of the case while watching a movie?  No, I think that’d be distracting.  It also doesn’t have a remote.  Well, the diNovo keyboard with integrated touchpad should do the trick there.  And it doesn’t have a volume control on the front of the case.  OK, that’s only an added bonus and nothing I’d miss anyway.

So the new case was ordered yesterday from Scan (along with a 1.5TB hard drive), and bless ‘em, it’s already been dispatched and I should have it today!  Whoever I ordered the CPU from needs to get in gear because I want to get buildin’!