Patrick Leblanc's Blog

KMZ test

Patrick Leblanc — Mon, 26 Jul 2010 20:52:44 +0000

Here is the track:

Building a simple MVC framework

Patrick Leblanc — Fri, 26 Mar 2010 22:09:18 +0000

Introduction

I don’t know about you, but it took me a while to fully grasp the concepts of MVCs. I mean sure, it’s a Model View Controller framework and the model manages the raw data and links it to the database, the controller manages the requests to a specific module and is the translator between “Model-talk” and “View-talk” – which should be mute btw – and the View displays what the controller says to display.

I’ll let you check wikipedia for all the theoretical details and the thousand related frameworks.

Courtesy of the Symfony project

Meanwhile, we have tons of schema explaining to you how they work, like this one, from the Symfony framework. We’ve all seen those, but they don’t really demystify the “How do they work?“. When you look at the code, it’s MASSIVE. And it seems working like magic.

This is a humble attempt to explain the basis of how all those frameworks work for the curious programmer. I’ve been strongly inspired to create this by the Zend framework, Symfony, Yii and a great tutorial found here.

I strongly discourage you from writing your own MVC for production purposes. Use one of the above, take time to learn it and run with it. I personally have a preference for Symfony because it uses Doctrine, which is one of my favorite PHP software ever. It’s an amazing ORM.

That being said…I strongly encourage you to write your own MVC to satisfy your curiosity

I don’t really know where I’m going to go with this but if it proves popular, I probably will expand the whole thing, bits by bits, just for fun! If i do though, be prepared for a lot of refactoring though, since there will be many problems. I kept this as simple and straight forward as possible to keep the code distraction free.

This part is all about the dispatcher. How do we fetch the right controller, output the right data. Oh, and one more thing before we get started: we know nowadays SEO is the bread and butter of the web. Therefore, we will directly code for plain text URLs. We will go down the rabbit hole as a request hitting the web server, and see, step by step, what’s going on and how is it working.

Let’s begin!

Configuration

Software: PHP 5.2+, Apache

First thing to understand is: all the traffic goes through ONE file first. Then we dispatch it, according to the URL. To do so, we need nice URLs, and to have nice URLs we need mod_rewrite and to have a functional rewrite, we need our directory structure!!

Here is how I did it. It’s a rough mix between symfony/yii/zend, since the 3 frameworks influenced me.

Basically, the app folder contains everything that is related to your application you are working on. (in my case, a book management for example)
The lib folder contains the framework, and shouldn’t be edited between projects.
The public folder is the HTDOCS. The only thing visible to the outside world. To do so, we have to configure our webserver first:

Now configure your Apache to have your virtual domain to point to the /public directory. Here is what my virtual host file look like:

NameVirtualHost 127.0.0.1
<VirtualHost  127.0.0.1>
    ServerAdmin postmaster@dummy-host.localhost
    DocumentRoot "D:/_Dev/sites/sandbox/mvc/public"
    ServerName mvc.localhost
    ErrorLog "logs/sandbox.lh-error.log"
    CustomLog "logs/sandbox.lh-access.log" combined
VirtualHost>

As you can see, it directly points to the public folder, which as nothing but an .htaccess file which redirect all the traffic to the index.php. let’s see the content of those file:
/public/.htaccess

RewriteEngine On
 
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [L]

Basically, a file or a directory that physically exists in the /public directory will be served. if not, we redirect to index.php

A visitor lands to your front page. What’s going on?

The .htaccess redirects to the index page.

/public/index.php


 
//simplifies our life.
define('DS', DIRECTORY_SEPARATOR);
define('ROOT', dirname(dirname(__FILE__)));
define('LIB_PATH', ROOT . DS . 'lib' .DS . 'smvc' );
define('APP_PATH', ROOT . DS . 'app');
 
$url = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
 
// validate a SEO friendly URL
 
if(filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED) === false)
{
   require_once(LIB_PATH . DS . 'bootstrap.php');
}
else
{
    throw new Exception('Invalid URL');
}

There is nothing special here. We define a couple of constants to make our life easier, we just make sure we got ourself a valid, SEO-friendly URL and if we do, we fire the bootstrap.
That one is the heart and soul of the MVC framework. That’s where the request is handle, so let’s go there!

/lib/smvc/bootstrap.php


/* 
 * This file is the nerveous system of the entire framework
 * It loads the config files and dispatches the requests. to the appropriate
 * controller.
 */
 
/**
 * This function automagically loads the required files, according to the name.
 * This is tighly used with the dispatcher.
 * @param string $className
 */
function __autoload($className) {
 
    if (file_exists(LIB_PATH . DS . $className . '.class.php')) {
        require(LIB_PATH  . DS . $className . '.class.php');
    } else if (file_exists(APP_PATH . DS . 'controllers' . DS . $className . '.php')) {
        require(APP_PATH . DS . 'controllers' . DS . $className . '.php');
    } else if (file_exists(APP_PATH . DS . 'models' . DS . $className . '.php')) {
        require(APP_PATH . DS . 'models' . DS . $className . '.php');
    } else {
        throw new Exception('Class not found');
    }
}
 
function dispatcher() {
 
    //'car' stands for Controller Action and Request
    $car = Smvc_Router::route($_SERVER['REQUEST_URI']);
 
    $cname = ucfirst($car[0][0]);
    $controller = $cname . 'Controller';
    $action = ucfirst($car[0][1]);
    $request = explode('/',$car[1]);
 
    $triggeredController = new $controller($request);
    call_user_func(array($triggeredController,'execute'.$action) , $request);
 
    extract($triggeredController->getViewVariables());
    ob_start();
    include(APP_PATH . DS . 'views' . DS . $cname . DS . $action . '.php');
    $smvc_content = ob_get_contents();
    ob_end_clean();
    include(APP_PATH . DS . 'views' . DS . 'layout.php');
    echo "\n\n";
 
}
 
dispatcher();

The function __autoload($className) is fired every time we call a class an PHP can’t find it. Obviously since we don’t include() any other file than the bootstrap, we won’t have any class loaded. So as you can see, to keep this system as light as possible, we load classes on demand only. This is crucial to keep performance independent of the size of the framework. You can have a hundred controllers and views, it shouldn’t be any much slower than if you have only a view and a controller. This function will probably be refactored in the future as it can be improved, but for now, I like its simplicity.

Now the dispatcher. As you can see, it’s the only function called in the scripts (for now). Everything else is class based. Once inside it, the first thing we do is analyze the URL with the router. I chose to put it in a class, it’s not really necessary at this point the function could have been included in the bootstrap.

/lib/smvc/Smvc_Router.php


/* 
 * This class finds the right Controller and Action according to the passed URL
 * and Routes.
 */
 
/**
 * Description of Router
 *
 * @author PLeblanc
 */
final class Smvc_Router {
 
    public static function route($url) {
 
        require_once(APP_PATH . DS . 'config' . DS . 'routes.php');
 
        foreach ( $routes as $pattern => $controllerAndAction ) {
            if ( preg_match('/^'. $pattern . '/', $url ) ) {
                $requestString = preg_replace('/^'.$pattern . '/', '', $url,1);
 
                return array($controllerAndAction, $requestString);
            }
	}
 
        //we should always find a route. If not, there is problem.
        throw new Exception('No routes were found');
 
    }
 
 
}

This file immediately fetches the routes for the application. For now we’re keeping things simple: the route is a simple Regex expression checked against the URL. If it’s found, we return the associated Controller and Action, with the remainder of the URL. Indeed, we remove the matching pieces from the URL since we assume it’s a description of a controller and an action, and consider the rest as arguments to be processed by the Controller.

Here is my route file:
/app/config/routes.php


/* 
 * This is the routing files. All URLs combinaitions should be written here.
 * The order is important as it will search from top to bottom.
 */
 
$routes = array (
        '\/book\/' => array('Book', 'Index')
    );

So this means that we are looking for a aurl such as mydomain.com/book/
This will send to the function dispatcher() the Controller, the Action, and the rest of the url, that will be treated as argument(s).

From line 31 to 34 in /lib/smvc/bootstrap.php, we prepare the variables to fit a convention. This helps keeping the code tidy. This is what I arbitrarily decided:

Classes files always start with a capital letter
Classes files are named after the class they contain
Controllers must have “Controller” appended to it, such as BookController.php
URL Actions inside controllers must start by “execute“, such as executeIndex
View folders and actions are have a leading capital letter too
I decided that ‘/’ represent break in arguments/routes. It makes sense in most SEO situations.

Then line 36, we simply create a new controller object, with the request as argument. In this case, if the path is /book/ it will match the first route and return the BookController, which is going to be instantiated.

36	$triggeredController = new $controller($request);

What we’re effectively doing in the case of the user trying to access mydomain.com/book/hello-world/how-are-you:

$triggeredController = new $BookController(array('hello-world','how-are-you')); //remember we explode the request on slashes ( '/' ) on line 34

This is what the BookController looks like:
/app/controllers/BookController.php


/**
 * Description of BookController
 *
 * @author PLeblanc
 */
class BookController extends Smvc_Controller {
 
    public function executeIndex() {
        $this->myRequest = 'This is my request: ' . $this->_request[0];
    }
}

As you can see, extremely basic for now. We’re just storing the 1st argument in a variable that is going to be used in the view. All the variables set like “$this->myVariable” are accessible to the view. We’re getting there in a minute. Meanwhile, the astute reader noticed we are extending an parent class. Here it is:

/lib/smvc/Smvc_Controller.php


/**
 * Description of Smvc_Controllerclass
 *
 * @author PLeblanc
 */
abstract class Smvc_Controller {
 
    protected $_request;
    protected $_viewVariables;
 
 
    public function __construct($request) {
        $this->_request = $request;
    }
 
    public function __set($name, $args) {
        $this->_viewVariables[$name] = $args;
    }
 
    public function __get($name) {
        return $this->_viewVariables[$name];
    }
 
    public function getViewVariables() {
        return $this->_viewVariables;
    }
 
}

As you can see, it’s a very simple and basic container class. We are using magic getter and setter to store all variables in a array. The request, meanwhile, is being stored by the constructor, so it’s readily available inside our controller as “$this->_request”.

In line 37, once the object is instantiated, we call the action associated by the matching route.

call_user_func(array($triggeredController,'execute'.$action))

The above code calls /app/controllers/BookController.php

    public function executeIndex() {
        $this->myRequest = 'This is my request: ' . $this->_request[0];
    }

As I said earlier on, all the variables set in the controller are then extracted in line 39. We’re doing this because the variables are then easily used in the view. Now we start the output buffer. This is because we want to have the view rendered in to a variable. We can then inject the view inside the layout file. This is a good practice because we don’t have broken HTML files (such as a traditional Header.php + Footer.php, like Wordpress is doing).

Here is the view used to respond to the index action:

/app/views/Book/Index.php

You made a request for the BOOK CONTROLLER

And this is the first argument passed:

echo $myRequest ?>

As you can see, we can use EVERY variables used in the controller directly in the view. If, in the controller, I used $this->helloWorld, I will be able to use $helloWorld in my view, thanks to the extract() line 39 of the bootstrap.php.
and finally the extremely basic layout page. as you can see, the layout path is hardcoded in the bootstrap. It’s probably something we will want to change in the future, but for now, it’s doing the job.

/app/views/layout.php


<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
  </head>
  <body>
    
  </body>
</html>

So there, you have it!

If you try to access it now, with this URL: http://mvc.localhost/book/hello-world you’re going to have this result:
————————————

You made a request for the BOOK CONTROLLER

And this is the first argument passed:

This is my request: hello-world

————————————-
However if you’re trying any other urls that don’t start with “book”, it’s gonna throw a fatal error, since no routes have been created for them! for example: http://mvc.localhost/hello-world

Fatal error: Uncaught exception 'Exception' with message 'No routes were found' in D:\_Dev\sites\sandbox\mvc\lib\smvc\Smvc_Router.class.php:27 Stack trace: #0
D:\_Dev\sites\sandbox\mvc\lib\smvc\bootstrap.php(29): Smvc_Router::route('/hello-world') #1 D:\_Dev\sites\sandbox\mvc\lib\smvc\bootstrap.php(49): dispatcher() #2
D:\_Dev\sites\sandbox\mvc\public\index.php(15): require_once('D:\_Dev\sites\s...') #3 {main} thrown in D:\_Dev\sites\sandbox\mvc\lib\smvc\Smvc_Router.class.php on line 27

Recap

It’s a lot to absorb. It’s going to take a while, but I really tried to keep things as simple as possible to begin this tutorial. Take some time to reproduce it step by step. I’ve included all the code in quotes, nothing is hidden. If you do it step by step and recode this MVC from scratch, you’ll have a much better understanding of how all this works.

Have fun!

Managing multiple threads in C# with a GUI

Patrick Leblanc — Sun, 21 Jun 2009 21:19:24 +0000

Objective: manage multiple threads from C# with a responsive GUI
Description:: In this example, I simulate encoding from a source that is splittable in segments. It could be the b-frames between I-frames in a video or even some sort of audio codec. To simulate the workload, I use Thread.Sleep(TimeInMs).

For this code, I have 4 threads working on a source to encode of 10 segments. Each threads will take a slice to encode, process it and reassemble the end result in an array, that can be utilized by another process to unify the encoded version, for example.

A word of caution though: although working with threads can be useful in some cases it also complicates the code quite a bit, especially at debugging. It’s much harder to keep track of what is going on.

Here is the code in the windows form (download the whole project in VS2008 at the end):

 
namespace bgGUI
{
 
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
 
    public partial class Form1 : Form
    {
        delegate void setTextBoxTextCallback(ArrayList a);
        delegate void setLabelTextCallback(string s, Label l); //delegate used to set the text on a label in a Invoke operation
        ArrayList videoSegments; //Imagine this as a collection video/audio segments we need to compute.
        int workingIndex; // This is to track where we're at in the videoSegments during the process.
        object lockObject = new object(); // the lock object used for the thread to safely pick a new segment to compute.
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            //Here we're gonna fake that the stack of videoSegements is full of 10 slice to encode.
            videoSegments = new ArrayList();
 
            for (int i = 0; i < 20; i++)
            {
                videoSegments.Add("this is segement " + i);//for the purpose of the demonstration I'm adding a string and its index.
            }
 
            workingIndex = videoSegments.Count - 1;
            label5.Text = videoSegments.Count.ToString();
 
            //We're starting 4 different thread with parameters (hence the use of the ParameterizedThreadStart Delegate)
            //Becareful though as ParameterizedThreadStart Start method only takes an objet argument. Therefore it's not type safe.
            //an alternative, type safe way of doing it is to create an helper class. and start it with ThreadStart
            //more details here: http://msdn.microsoft.com/en-us/library/ts553s52.aspx
            //In my example, I pass as argument an anonymous object containing a Label and an int which is the a time interval in ms. 
            //(the interval is used to simulate heavy load.)
            Thread t1 = new Thread(new ParameterizedThreadStart(tsChangeLabelText));
            t1.Start(new object[] { label1, 2500 });
 
            Thread t2 = new Thread(new ParameterizedThreadStart(tsChangeLabelText));
            t2.Start(new object[] { label2, 3500 });
 
            Thread t3 = new Thread(new ParameterizedThreadStart(tsChangeLabelText));
            t3.Start(new object[] { label3, 1000 });
 
            Thread t4 = new Thread(new ParameterizedThreadStart(tsChangeLabelText));
            t4.Start(new object[] { label4, 1250 });
 
        }
 
        private void tsChangeLabelText(object o)
        {
 
            //we cast the object as an array.
            //then we extract the first object at index[x], then we cast it to what we want
            //as i said earlier, it's not type safe. use it with caution!
            Label l = (Label)((object[])o)[0];
            int ms = (int)((object[])o)[1];// the ms is just to simulate heavy load on the thread
 
            int insideIndex = 0; // This will be the index we're going to compute
 
            while (workingIndex >= 0) // the thread will go on until all the segments have been computed
            {
                lock (lockObject) // we request a lock on the object. If successful, all the other threads will wait for this to unlock.
                {
                    //We have to check again if there are segments remaining!
                    //indeed, another thread could have snatched the last one between our 'while' and this lock!
 
                    if (workingIndex > -1)
                    {
                        insideIndex = workingIndex; //We're going to compute the segment located at this index in our collection;
                        workingIndex--;//The other threads will be able to go to the next one after the end of the lock
                    }
                }// now all other threads (those waiting for permission to use the lock)
                // will be able to check what the working index is and pick the next segment.
 
                //we display infos on the GUI using invoke since it's not the owner thread.
                setLabelTextCallback d = new setLabelTextCallback(setLabelText);
                setTextBoxTextCallback z = new setTextBoxTextCallback(setTextBoxText);
                this.Invoke(d, new object[] { "Working on segment #" + insideIndex, l });
 
                //---------------------------
                Thread.Sleep(ms); // simulate the heavy load of the Encoding
                //---------------------------
 
                this.Invoke(d, new object[] { "DONE WITH segment #" + insideIndex, l });
 
                videoSegments[insideIndex] = (string)videoSegments[insideIndex] + " - COMPUTED"; // let's say that we replaced the old segement with the new one
                this.Invoke(z, new object[] { videoSegments });
                this.Invoke(d, new object[] { (workingIndex + 1).ToString(), label5 });
 
                Thread.Sleep(3000);//this is only for you to see what's going on
 
            }
 
        }
 
        private void setLabelText(string s, Label l)
        {
            l.Text = s.ToString();
        }
        private void setTextBoxText(ArrayList a)
        {
            //to check the order of the ouput
            textBox1.Text = "";
            for (int i = 0; i < a.Count; i++)
            {
                textBox1.Text += a[i].ToString() + Environment.NewLine;
            }
 
        }
 
    }
}

Download this Project!

C# Crash report – How to handle remote crash report with HTTP POST

Patrick Leblanc — Sun, 19 Apr 2009 19:36:38 +0000

Objective: Make your applications report any unhandled crash to a database on a remote server.
Description:You have a Reporter class that will send the values to page accepting POST data. The application main entry point will be surrounded by a Try Catch block (effectively catching every possible unhandled errors in the application). It will then try to send the stack trace of the error to the webpage. If it can’t (ie. no internet connection, server down) it won’t do anything and the application quits.

It can be very useful to catch those bugs you didn’t see or thought possible without mass testing and QA…which, let’s face it, you can’t afford as a self programmer. Your users are your testers!
A word of caution though, you might want to warn your users you’re sending data, and what kind of data you’re sending before using this. In this example, it doesn’t warn the end user.

On to the code below the break!

Reporter.cs

You need to add a reference (Projet->Add Reference…->System.Web) so you can access the urlencoder

using System;
using System.IO;
using System.Net;
using System.Text;
 
namespace ErrorReport
{
 
    //shamelessly copied from http://msdn.microsoft.com/en-us/library/debx8sh9.aspx
    class Reporter
    {
 
        private WebRequest request;
        private string postData;
 
        public Reporter (string url)
	{
            // Create a request using a URL that can receive a post.
            request = WebRequest.Create (url);
            // Set the Method property of the request to POST.
            request.Method = "POST";
            // Set the ContentType property of the WebRequest.
            request.ContentType = "application/x-www-form-urlencoded";
            postData = "";
 
	}
        /// 
        /// Add an combination of key/value to post to the server
        /// 
        ///
the identifier you'll use while retrieving the POST data
        ///
value of the POST for that key
        public void AddItem(string key, string value)
        {
            postData += "&" + key + "=" + System.Web.HttpUtility.UrlEncode(value);
            //clean up so we make sure it doesn't start with a &amp;
            postData.TrimStart('&');
        }
        public void Post()
        {
            byte[] byteArray = Encoding.UTF8.GetBytes(postData);
            // Set the ContentLength property of the WebRequest.
            request.ContentLength = byteArray.Length;
            // Get the request stream.
            Stream dataStream = request.GetRequestStream();
            // Write the data to the request stream.
            dataStream.Write(byteArray, 0, byteArray.Length);
            // Close the Stream object.
            dataStream.Close();
            // Get the response.
            WebResponse response = request.GetResponse();
            // Display the status.
            Console.WriteLine(((HttpWebResponse)response).StatusDescription);
            // Get the stream containing content returned by the server.
            dataStream = response.GetResponseStream();
            // Open the stream using a StreamReader for easy access.
            StreamReader reader = new StreamReader(dataStream);
            // Read the content.
            string responseFromServer = reader.ReadToEnd();
            // Display the content.
            Console.WriteLine(responseFromServer);
            // Clean up the streams.
            reader.Close();
            dataStream.Close();
            response.Close();
 
        }
 
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Windows.Forms;
 
namespace ErrorReport
{
    static class Program
    {
        /// 
        /// The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {
            Reporter r = new Reporter("http://example.com/postDataHandler.php");
 
            try
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new Form1());
 
            }
            catch (Exception e)
            {
                try
                {
                    //Now i add my post items. in this example, they will be retrieved as such:
                    //$_POST["ERRORMSG"] and $_POST["STACKTRACE"]
                    //Of course this is entirely customizable to your need!
                    r.AddItem("ERRORMSG", e.Message);
                    r.AddItem("STACKTRACE", e.StackTrace);
                    r.Post();
                }
                catch (Exception)
                {
                }
                finally
                {
                    MessageBox.Show("A fatal error has occured, the application will now be terminated","ERROR",MessageBoxButtons.OK,MessageBoxIcon.Error);
                    Application.Exit();
                }
 
            }
 
        }
    }
}

So this is the C# code. As you can see it’s pretty simple! if anything crashes in the form1, it will be reported and posted to http://example.com/postDataHandler.php

I created a very simple table on my database to handle the storing of those infos

errorReport.sql

DROP TABLE IF EXISTS `errorReport`;
CREATE TABLE IF NOT EXISTS `errorReport` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `errormsg` varchar(255) NOT NULL,
  `stacktrace` text NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

the code above will create the MySQL table, now on the code of postDataHandler.php!

postDataHandler.php

And there you go! Everytime the application crashes it will send the stacktrace to your MySQL server. Of course, it can be very easily adapted to your needs, and works exactly the same way is ASP. If it’s for an intranet use, then you just need to adapt the Reporter.cs to use a dataAdapter and a MSSQL server. There is no need to use POST in this situation. This is more useful for programmers like me who have a homepage, but whose software can be use by anyone around the world.

Enjoy yourself!

Hello world!

Patrick Leblanc — Mon, 17 Nov 2008 17:20:22 +0000

I’m revamping this site!