"client denied by server configuration: ..."

I had missed that apache now ships with a slightly different configuration for the / directory to

<Directory />
    Options FollowSymLinks
    AllowOverride None
    Order deny,allow
    Deny from all
</Directory>

The Order deny,allow and Deny from all makes the virtual hosts inaccessible by default. When I googled it I saw many forum and blog posts asking about this issue.

To fix it you can either remove/change the lines. But that is probably not a good idea. Better is to explicitly specify which directories that apache are allowed to serve. So for me and my project setup it was as simple as adding a new directory directive opening up my www directories for all the projects.

<Directory />
    Options FollowSymLinks
    AllowOverride None
    Order deny,allow
    Deny from all
</Directory>

<Directory "/home/myusername/Projects/*/www">
    Order deny,allow
    Allow from all
</Directory>

I hope this short explanation helps a few people looking for a solution to the problem.

"Using your brain while developing is really helpful" - Lars Jankowfsky. Maybe I should stop the bad habit of lazy coding while watching TV...

One thing that makes me happy is that they have added a session on Zend Framework. I look forward to that as I have begun to rely on Zend Framework quite a lot.

IPC 2007 and Ajax In Action

Lars Jankowfsky during his session

Representing a tree of nodes, for example product categories, in a relational database is not hard. The most common way of doing it is to store a parentid with each node. This is also known as the adjacency list model. It is sometimes also referred to as the recursive model. Whatever the name it is easy to grasp. It is very simple to insert and move nodes around but it is not an optimal solution if you often select the whole tree from the database for displaying on a web page as you need to recursively select all children of nodes.

The nested set model

A much better solution is the nested set model. In this model trees are represented as nested sets. Instead of using a parentid you have a left and right value for each node expressing the relationship to other nodes. A tree of nodes can look like this.

        34
         |
         +--36
         |   | 
         |   +--46
         |   |
         |   +--47
         |
         +--38
             |
            +--39

The same data can be viewed more graphically as nested sets. This is also the way they are stored in the database. Notice how the left and right values are numbered in order from the outermost left to the outermost right.

                            id:34
   +----------------------------------------------------+
   |             id:36                     id:38        |
   |   +------------------------+    +--------------+   |
   |   |    id:46      id:47    |    |     id:39    |   |
   |   |   +-----+    +-----+   |    |   +------+   |   |
  1|  2|  3|     |4  5|     |6  |7  8|  9|      |10 |11 |12
   |   |   +-----+    +-----+   |    |   +------+   |   |
   |   +------------------------+    +--------------+   |
   +----------------------------------------------------+

In the database this is stored as in the following table.

 +----+-----+-----+
 | id | lft | rgt |
 +----+-----+-----+
 | 34 | 1   | 12  |
 | 36 | 2   |  7  |
 | 46 | 3   |  4  |
 | 47 | 5   |  6  |
 | 38 | 8   | 11  |
 | 39 | 9   | 10  |
 +----+-----+-----+

This allow you to select the full tree with only one select statement. Normally you select the full list of nodes including the depth of each node as shown below in the small table containing id and depth. It is then easy to loop over the data in PHP to produce a nice tree in HTML/CSS.

The data below can be displayed as the the tree on right. The depth is in parenthesis.

 +----+-------+        34 (0)
 | id | depth |         |
 +----+-------+         +--36 (1)
 | 34 | 0     |         |   |  
 | 36 | 1     |         |   +--46 (2)
 | 46 | 2     |         |   |
 | 47 | 2     |         |   +--47 (2)
 | 38 | 1     |         |
 | 39 | 2     |         +--38 (1)
 +----+-------+             |
                            +--39 (2)

Here is a more thorough article on how you use MySQL with nested sets.

On to the problem

Last night I was working on an application that display a full tree where the user must be able to to drag and drop nodes to reorder the tree. The problem is that it is much more difficult to insert or reorder the tree using the nested set model.

For the actual html I produced nested ordered lists using the OL and LI html element so that it was easy to use with the excellent MooTree script based on MooTools. (It does seem to have trouble with the latest version of MooTools though.) After reordering the structure it was easy to extract the tree list including the depth of each node. I sent this to the PHP backend to be handled there. The text data I sent to the PHP backend then look like below.

 34,0
 36,1
 46,2
 47,2
 38,1
 39,2

As you can see it looks exactly like the data I selected from the database previously. So I had to create a function in PHP that took this indata and produced a list of nodes with the correct left and right values. This list is then looped over to update all the nodes in the database.

function depth2nestedset($data)
{
  $lines = explode("\n", $data);
  $rows = array();
  $stack = array();

  $lft = 0;   // Left value
  $rgt = 0;   // Right value
  $plvl = -1; // Previous node level

  foreach($lines as $line) {
    list($id, $lvl) = explode(',', $line);

    // Skip empty/faulty lines
    if (trim($id) == '') {
      continue();
    }

    if ($lvl > $plvl) {
      $lft++;
      $rgt = 0;
      array_push($stack, $id);
    }
    else if ($lvl == $plvl) {
      $pid = array_pop($stack);
      $rows[$pid][2] = $rows[$pid][1] + 1;
      $lft = $lft + 2;
      $rgt = 0;
      array_push($stack, $id);
    }
    else {
      $lft = $lft + ($plvl - $lvl) + 2;

      $diff = $plvl - $lvl + 1;
      for($n = 0; $n < $diff; $n++) {
        $pid = array_pop($stack);
        $rows[$pid][2] = $lft - $diff + $n;
      }
      array_push($stack, $id);
    }

    $rows[$id] = array($id, $lft, $rgt);
    $plvl = $lvl;
  }

  $plvl++;
  $cnt = count($rows) * 2;
  $leftovers = count($stack);

  for($n = 0; $n < $leftovers; $n++) {
    $pid = array_pop($stack);
    $rows[$pid][2] = $cnt - $plvl-- + $n;
  }

  return $rows;
}

The resulting associated array that is returned looks like below.

Array
(
    [34] => Array
        (
            [0] => 34
            [1] => 1
            [2] => 12
        )
    [36] => Array
        (
            [0] => 36
            [1] => 2
            [2] => 7
        )
    [46] => Array
        (
            [0] => 46
            [1] => 3
            [2] => 4
        )
    [47] => Array
        (
            [0] => 47
            [1] => 5
            [2] => 6
        )
    [38] => Array
        (
            [0] => 38
            [1] => 8
            [2] => 11
        )
    [39] => Array
        (
            [0] => 39
            [1] => 9
            [2] => 10
        )
)

That makes the circle complete. From left/right values in the database to a node tree based on depths that is easy to manipulate in html and then back to left/right values. Hopefully this makes sense. Do you have a better solution or more examples on applications that do this I would love to hear about it.

This year seems to be different though. A whole slew of interesting sessions on PHP mixed with a few sessions on agile development. Sounds just about perfect to me. I am especially interested in the one PHP 6 session as I have not had the time to follow what is happening in regards to next major version of PHP. I'm definitely going to Frankfurt this November. There are still too many sessions in German if you ask me - but I guess there are quite a few Germans going to the conference.

Naturally I went to the almighty Google for the answer. There are a few excel writers written out there. I found a tutorial on using PEAR Spreadsheet_Excel_Writer and an MS-Excel Stream Handler class to mention two solutions.

I found one piece of code floating around numerous places that I fell for. I am not sure about the original source for this code though. Extremely simple.

function xlsBOF() {
    return pack("ssssss", 0x809, 0x8, 0x0, 0x10, 0x0, 0x0);  
}

function xlsEOF() {
    return pack("ss", 0x0A, 0x00);
}

function xlsWriteNumber($Row, $Col, $Value) {
    return pack("sssss", 0x203, 14, $Row, $Col, 0x0)
      .pack("d", $Value);
}

function xlsWriteLabel($Row, $Col, $Value ) {
    $L = strlen($Value);
    return pack("ssssss", 0x204, 8 + $L, $Row, $Col, 0x0, $L)
      .$Value;
}

I liked it because it did what I wanted with a minimum of fuss. I was happy until I realized I don't understand it enough to be able to set the character set. Right now question marks appear in the texts instead of national Swedish characters as å, ä and ö.

However, before I decided to host a software project somewhere else I would thoroughly investigate how easy it is to export the whole repository with version history intact.

The problem seems to be that PHP use the ini directive sendmail_from to set the from email address in the SMTP protocol. If this is not correctly set, or if it does not match the from header in the email headers, the email is caught by spam protection software.

The simplest solution is to set the directive during execution:

ini_set("sendmail_from", $email_from);

$headers = "From: $email_from";

mail($to, $subject, $message, $headers);

The problem as well as the solution was already known by others. The operating system this time was windows and I know there are differences in the implementation between the windows and linux version of mail(). I am not sure if the problem exist on both platforms.

Still I bet there are lots of people out there with this problem without them knowing it. It could be a good idea to include more detailed information about this ini entry and its implications in the actual mail() documentation. Sending emails from web pages is, to say the least, a very common task.

Searching Google I finally found a MySQL article on the nested set model which is a lot more efficient. The algorigthm basically skips the whole parent/child relationship between nodes. Instead you work with what is best described as "neighbouring" nodes. This allows you to retrieve a fully ordered hierarchical tree, including the level/depth of each node in the tree, using only one simple sql statement.

Those that are not familiar with the nested set model should definitely read the article.

What I want to aggregate are Swedish web development and web entrepeneur blogs. I like the planet-planet concept that for example planet-php use. (Though I don't think planet-php use python...) Conveniently I had this idn domain, översikt.se, lying around which I haven't used up until now. As is normal nowadays (for me at least) I used Zend Framework to build the site. It was the first time I used Zend_Feed class. I works like a charm.

The whole website logic (both model and controller) is about 200 lines of code. And the main logic of fetching the feeds are really nice and short.

foreach($urls as $url) {
    try {
      $feed = Zend_Feed::import($url['feedurl']);
    }
    catch(PDOException $ex) {
      error_log($ex->getMessage());
      continue;
    }

    $feedTitle = $feed->title;
    $feedLink = $feed->link;
    $title = '';
    $link = '';
    $desc = '';
    $pub = '';

    foreach ($feed as $item) {
      if (is_a($feed, "Zend_Feed_Rss")) {
        $title = $item->title();
        $link = $item->link();
        $desc = $item->description();
        $publ = ($item->pubDate()) ? $item->pubDate() : $item->date();
      }
      else if(is_a($feed, "Zend_Feed_Atom")) {
        $title = $item->title();
        $link = $item->link('alternate');
        $desc = $item->content();
        $publ = ($item->issued()) ? $item->issued() : $item->published();
      }
      else {
        error_log("Feed <$feedid> is an unsupported format");
        continue;
      }

      // Parse and normalize date and check if new
      $time = strtotime($publ);
      $publ = date("c", $time);

      // Execute the previously prepared sql insert statement
      $result = $sti->execute(array(
          'feedid' => $url['feedid'],
          'title' => $title,
          'link' => $link,
          'publ' => $publ,
          'desc' => $desc));
    }
}

I skipped database exception and error handing in the above code to make it even more readable. Zend_Feed have failed me only once when trying to read and parse an old weird rss format. Wonderful.

(For those that don't have browsers that support idn-domains I linked to the punycode variant of the domain name översikt.se, www.xn--versikt-80a.se, above. But mostly because my damn editor refuses to use the Swedish letter "ö" in the href attribute.)