EnterpriseApplications@blogger.com

Observers and Subjects

2006-08-26T16:05:00.000+02:00

The most well-known design pattern for decoupling object instances or classes from one another and still have a mechanism for the observer to know, when a particular event occurs on a subject, is the Observer-Pattern. The implementation is typically done either using abstract classes or using interfaces.

While the prior has the advantage that the abstract classes may provide a reusable behaviour for observer registration and notification it limits an observer to stay in the observer role. It's not possible for an observer of one subject, to act as a subject itself (unless, you are relying on implicit coding/naming conventions rather than on an explicit mechanism). While this may not be a problem with languages allowing multiple inhertiance, it is for languages that support single inheritance only.

The latter (inteface-based) approach, releaves you of this issue at the cost of implementing the required methods on every class that wants to make use of the pattern. While this may be inconvenient it is a valid means to resolve and works most of the time.

With dynamic languages such as PHP or JavaScript there is yet another way to approach the issue using a mediating class that organizes the eventhandling between abitrary objects (or classes or basically any entity you may think of). Let's show an example for the usage of this approach:

class Event { ... }


class Subject {

 public function doSomething() {
  //do something and throw the event
  Event::raise($this,'onDoSomething');
 }

}


class Observer {

 public function onEvent(Event $event) {
  //react to the event
  echo get_class($event->getSourceObject());
 }

}

$subject = new Subject();
$observer = new Observer();
Event::register($subject,'onDoSomething',$observer,'onEvent');
$subject->doSomething(); //prints 'Subject'

What you are now probably interested in the most is the implementation of the "Event"-class. As you have seen there are two static methods on it:

1) register() allows to register abitrary methods or functions to be registered as callbacks for a particular event - 'onDoSomething' in this case - of objects or classes (the latter is not yet supported by the following implementation)

2) raise() allows to indicate the occurrence of a particular event on an object or class (the latter is not yet supported by the following implementation). All previously registered callback methods (you may as well call them the observers) will be executed using a single argument: an "Event"-object instance.

This object may be used to query for particular aspects of the event happening using one of the following methods.

1) getSourceObject() returns the subject the event occurred on if existing

2) getName() returns the name of the event so that the observer may decide how to handle different types of events, if this is not already distinguished using different callback methods.

3) getTargetObject() returns a reference to the observer if it is an object instance

4) getTargetMethod() returns the name of the callback method

5) getParameters() return an array of additional parameters that the subject may hand over to raise().

A possible implementation of the "Event"-class may look shown below. Please note that this version currently only supports object-to-object event handling:

class Event {

    protected $targetObject;
    protected $targetMethod;
    protected $eventName;
    protected $sourceObject;
    protected $parameters;

    protected function __construct($targetObject,
                                   $targetMethod,
                                   $eventName,
                                   $sourceObject,
                                   array $parameters = array()) {
        $this->targetObject = $targetObject;
        $this->targetMethod = $targetMethod;
        $this->eventName = $eventName;
        $this->sourceObject = $sourceObject;
        $this->parameters = $parameters;
    }

    public function getSourceObject() {
        return $this->sourceObject;
    }

    public function getName() {
        return $this->eventName;
    }

    public function getTargetMethod() {
        return $this->targetMethod;
    }

    public function getTargetObject() {
        return $this->targetObject;
    }

    public function getParameters() {
        return $this->parameters;
    }

    public static function raise($onObject,
                                 $event,
                                 array $parameters = array()) {
        foreach($onObject->__eventRegistry[$event] as $target) {
            if($target[0]) {
                call_user_func_array($target,
                                     array(
                                         new Event(
                                             $target[0],
                                             $target[1],
                                             $event,
                                             $onObject,
                                             $parameters)
                                     )
                );
            } else {
                call_user_func_array($target[1],
                                     array(
                                         new Event(
                                             NULL,
                                             $target[1],
                                             $event,
                                             $onObject,
                                             $parameters)
                                     )
                );
        }
    }

    public static function register($sourceObject,
                                    $forEvent,
                                    $targetObject,
                                    $targetMethod) {
        $sourceObject->__eventRegistry[$forEvent][] = array($targetObject,$targetMethod);
    }
}

This implementation should be session-save as well, as the dynamically built "__eventRegistry" should be serialized to and restored from the session automatically. For class based event registries this may be a little more tricky to implement.

But once the "strict" keywork is incorporated into PHP, this approach will not work on classes anymore that are marked strict.

Enumerations in PHP

2006-08-19T08:18:00.000+02:00

Sometimes you stumble over stuff on the net and really think to yourself. Wow! Why does not everybody talk about it yet? My Subject of the day is Enumerations in PHP via SPL_Types. Basically it brings Enumerations to PHP, ensuring that a variable may only contain specific values based on a value domain. This should be looking something like this.

class Weekday extends SplEnum
{
  const Sunnday = 0;
  const Monday = 1;
  const Tuesday = 2;
  const Wednesday = 3;
  const Thursday = 4;
  const Friday = 5;
  const Saturday = 6;
  const __default = Weekday::Sunday;
}

$e = new Weekday;

var_dump($e); // shows object of type SplEnum
var_dump((int)$e); // int(0)

$e++;

var_dump($e); // shows object of type SplEnum
var_dump((int)$e); // int(1)
var_dump($e + 3); // int(4)

I have found this example over at a mailing list transcript at BeebleX. While there is certainly a trace of this functionality in the CVS Repository at php.net you cannot yet get a precompiled version of the extension at PHP-Snaps :-(.

Personal note: While I love PHP for the fact that it's a dynamically typed language, I consider Enumerations a big help, to communicate and ensure consistency of parameter values on public interfaces.

Validating user input using PECL::filter

2006-08-19T07:59:00.000+02:00

PECL::filter is a new promising PHP extension, which will come with the new PHP 5.2.0. It is mainly meant for validation of input, which currently requires quite some work. Since there is no documentation over at php.net you can read all about it over here. For all the guys using Windows for your development environment here you can download the compiled extension for your current PHP installment.

Calculating distances

2006-08-10T12:41:00.000+02:00

Since I seem to have a fav on geo-calculation since Google-Maps has hit me, I have been looking for some information how to calculate distances between to points on the globe.

The GoogleAPI actually has a method to calculate the distance between points based on a shperical model.

But what if you'd like to implement a radius search on the database or calculate distances on the backend. I found a nice introduction for the subject over at MeridianWorldData, which takes into account various levels of precision to gain performance, where it is needed.

Also I found a PHP based example for distance calculation as well as a series of articles on the subject of GIS mapping.

Mashup GoogleMaps and GeoIP

2006-08-10T10:20:00.000+02:00

Ok I have put together a small example of how to use GoogleMaps and GeoIP. Use it to look up where a specific URL or server is hosted.

You can view it here. The application includes a bookmarklet, which you may bookmark or place in the link's bar of your browser to use it from every website to determine it's location.

For all you PHP freaks, you can download the complete example as well. Just unpack the ZIP file on your PHP5-enabled server and you should be good to go. Just make sure to use your own GoogleMaps API key, you can get here.

Republished CSTL

2006-08-10T07:49:00.000+02:00

I have just republished the article and samples about CSTL (Client Side Tag Libs), which brings TagLibs to JavaScript in an extensible object oriented model. The original articles are well 1 1/2 year old but since everyone seems to talk about AJAX these days, I just want to show, that I had my 50cent to distribute to that subject a long time ago. Besides the links were not working in quite a while.

full article download files

Matching IP to country

2006-08-09T14:01:00.000+02:00

I have again found a nice article about how to match IPs to countries over at builder.com. It uses PHP::Pear's Net_GeoIP class for the querying. But what really interest me is the data behind it. Luckily MaxMind does provide this data in various flavors.

There is a free CSV export at the beginning of every month, which can be downloaded on country level and on city level.

However there are also 2 APIs for PHP. For once there is a pure PHP implementation and also a PHP extension as well.

I am definately going to try these out!

Creating MS Office documents using PHP

2006-08-08T08:32:00.000+02:00

I have recently discovered an article on how to generate MS Office Documents using PHP. Basically this article does not contain anything new, demonstrating how to utilize the COM API to construct Word and Powerpoint and how Excel can be created from an HTML table. While this article will not enable you to approach the issue in an OS independent way (you will in fact need a windows server to create Word and Powerpoint documents) it still assembles the concepts for all 3 major MS Office products, containing easy to understand code snippets.

Google Code - APIs and more

2006-07-29T18:51:00.000+02:00

The recent hype for mashup-applications has certainly fueled the run on the it's AJAX Maps API. But there are plenty other APIs, which google offers, also worth a look. What will be certainly interesting for me, will be the Blogger Atom API which you can use to search and modify your blogs on www.blogger.com.

Also Google now hosts your open source projects, similar to the sourceforge.net way.

PHP Sockets Made Easy

2006-07-29T18:32:00.001+02:00

There is a really nice tutorial up about creating and consuming sockets usiung PHP. At the time of this writing the first part of a 5 part tutorial series is published. I am going to following it, since I have recently written a generic Socket-Server and want to see things, I may improve.

dompdf - The PHP 5 HTML to PDF Converter

2006-07-18T16:28:00.000+02:00

Finally there seem to be a decent API for PHP developers to render HTML to PDF. I have just downloaded and unpacked domPdf on my WAMP and it worked right away.

Ok I had to disable php_domxml.dll first but after that it worked perfectly. Well almost, since there seems to be a problem with special characters. I guess I need to import some additional forms first before this works correctly.

Anyhow this API is a big step forward for PHP developers trying to find an easy and convenient way to create PDFs from what they know best: PHP and HTML.

Featured Tutorial Series - Client Side Tag Libs

2005-01-30T13:34:00.000+01:00

Client Side Tag Libraries (CSTL) are a JavaScript based infrastructure that enables web developers and designers to employ custom tags into a (X)HTML page. Custom tags are mainly used to have easy access to sophisticated UI components. Underneath CSTLs are based on JavaScript classes that provide object oriented features like inheritance, polymorphism etc. and on top of that are easily distributable and redistributable across even across domains.

A TagLib enhanced (X)HTML document needs to loads the so called TagLibProcessor, as an external JavaScript file. The processor then looks for TagLibs registered in the <head> section of the document. After loading the TagLibs, the DOM is traversed finding and processing all custom tags – which should be XML namespaced.

A custom tag brings with it a convenient manner to create UI components in a JavaScript class, by either direct and eased DOM modification or even easier (X)HTML generation. Also you can bind variables to custom tag attributes that may refer to JavaScript variables, objects and functions, which are resolved into their real values behind on demand. Also every tag can be independently refreshed, either on a timed basis or in reaction to events, always serving you the current variable situation. This is the base for great flicker free user experiences.

<html>
  <head>
     <script type="text/javascript" src="cstl.js"></script>
     <cstl:taglib classPath="com.inspirationlabs.taglib.std.StdTagLib" ns="std"/>
     <script type="text/javascript">
        function date() {
           return new Date();
        }
     </script>
  </head>
  <body>
     <std:print var="${date}" refreshRate="1000">
        N/A
     </std:print>
  </body>
</html>

full article download files

How those articles are coming

2005-01-11T10:39:00.000+01:00

I was promising some articles and yes I didn't forget. In fact I am currently working hard on it. Just wanna make it sure that the example code behind the article is at least beta. Currently I am still working a little on the TagLibs as there are some small issues. Yesterday I had to completely rewrite my JavaScript class-building framework as I seem to have forgotten about static method inheritance.

But I have also started writing a good piece. The first article will be about the Client Side TagLibs (CSTL), which are probably the most "revolutionary" idea. After that I will probably get the JavaScript class-building framework (the base for it all) on the road. I hope that some of that will happen this week ;-)

Integrating instant messengers into a website

2004-12-30T13:01:00.000+01:00

Websites are an asynchronous media. You visit you view and maybe write a mail either via your e-mail client or via a web form. But there are times, when you want to be contacted synchronously. Some people just like being available to the world, others (e.g. sales representatives) want to have a way to directly be in contact with their customers. Whatever reason you might have to provide a synchronous contact to yourself. Here are various ways to do it.

ICQ (download)

I don't know if this is still the best or even a good IM but I started out with it and now I am stuck. However ICQ is very omnipresent.

Message Center
All of the techniques described here are also accessible though a user's message center. This is basically a web page located at

http://www.icq.com/whitepages/wwp.php?uin=98057455

which stores about all information about the user.

Sending a message
If you also have ICQ installed you can have links everywhere on the web which will open up your ICQ providing a chat window to the addressent. Those links must look like this:

http://www.icq.com/whitepages/cmd.php?uin=98057455&action=message

Adding user to your contact list
Same thing as above: Interaction with your ICQ to add a user. Uses the following link:

http://www.icq.com/whitepages/cmd.php?uin=98057455&action=add

to do so.

Skype (download)

Skype is currently the best tool I know for VOIP-Telephoning. Recently with their first stable release, you can also globally call into the telephony-networks. It uses pretty little bandwidth and is completely free of charge if you stay on peer-to-peer VOIP-calls.

Calling a user
You can embed simple links into your website, which (if Skype is installed on the client) open up Skype and initiate a call to the user. The Links must look like this:

callto://WittRaider

AIM (download)

AOL Instant Messenger was probably second most popular, when I was using it back a few years ago.

Send a message
Just like with ICQ you can directly send a message through you client installation of AIM to the addressent by clicking a link like:

aim:goim?screenname=WittRaider&message=hello

Others

I know that I have currently been missing out on other instant messengers like MSN or Yahoo now. Sorry for that maybe later. Also you may always want to integrate a chat, possibly on an IRC base.

Upcoming articles on this blog

2004-12-28T10:02:00.000+01:00

I just wanted to inform you what to expect on this blog in the next days/weeks. I have been experimenting with three main subjects over the last weeks, which I now want starting to present to the world ;-)

JavaScript classes and code distribution

As a preparation for the following two subjects I have implemented JavaScript classes, meaning I have been looking around the web and aggregating method how to create JavaScript structures which behave like classical object oriented classes providing features such as inheritance, polimorphism and the likes. Also I wanted classes to be distributable in multiple files across multiple servers and still be loadable on the fly, in order to increase cross-domain reusability of JavaScript objects.

Interaction between JavaScript and Flash

This became critical when designing the MP3-Player for the music section of this homepage. I wanted a generic way to interact with Macromedia Flash objects via JavaScript guaranteeing a bidirectional communication via remote function calls and distributed event publishing, even across the domain scripting border and across all browsers I use (being Internet Explorer, Mozilla/Netscape and Opera).

Client-sided TagLibs

Developers in touch with J2EE or at least JSP know JSTL (Java Standard TagLib), also know about the power to such a templating language. Now there are mechanisms which allow tag lib type technology on the client using JavaScript. Sound interesting? It certainly is! So stay tuned on this blog!

The Addison-Wesley Signature Series

2004-11-27T16:27:00.000+01:00

The Addison-Wesley Signature Series Series is a great series of books for anyone interested in enterprise application architectures and whose daily work is designing and maintaining those systems.

I personally own three books of the series and each one is both a great reference and a well entertaining piece of literature as well. So let me introduce the three to you.

Patterns of Enterprise Application Architecture

by Martin Fowler

As the title states the book focusses on enterprise application architecture patterns. It's one of the eariler books of the author. The first 100 pages or so build up typical scenarios and face you with the typical problems with enterprise applications. At that time Martin probably had more a focus in the backend and infrastructure. Therefore the typically 3-tiered approach comes a little short on business logic tier and presentation tier (still about 100 pages about those subjects and great patterns to deal with common problems).
What Mr Fowler really focuses this book on are relational database to domain model mapping patterns and concurrency issues that occur when more than one person tries to manipulate the same data or access a transactional service.
Since at the time I bought this book I was quite firm on the presentation tier and were just building a generic relational database to object mapping and persistence layer the book was absolutely perfect for me. I dug it! And you will, too! This book is perfectly structured. After the motivation part which introduces the main issues patterns to solve those issues are presented in a reference manner. Also the author puts great emphasis on educating the reader when to use specific patters. Basically all patterns also have a reference implementation either in Java or C#.

Enterprise Integration Patterns

by Gregor Hohpe, Bobby Woolf

The first book of the series I bought is a perfect addition to the Patterns of Enterprise Application Architecture just introduced. It focusses on Service Oriented Architectures. The structure is basically identical to the previous one. An introductionary chapter makes you acquainted with the basic facts of life that occur in distributed applications.
I was pretty happy about the fact that this book does not focus on Web Services only but instead tries to explain, which technology is well suited in which cases of a messaging architecture.
This book also can be used as a reference as it introduces patterns in a way that suites this need.
Alltogether this is also a brilliant book which is worth buying if you have to deal projects which are not planned on the green but have to coexist, leverage and interconnect existing software architectures.

Beyond Software Architecture

by Luke Hohmann

This book unlike the other ones in the series is not intended for the developer or at least it does not intend to solve technical issues. It rather focusses on the facts how software is, can and should be developed not to built the ideal solution to a problem but rather to build a solution that fits the user requirements. Yeah, techies tend to ingnore the end-users more and more the more they start loving their creation. This is a dangerous path to go down since your ideals seldomly put food on your plate.
This book also does not ignore the fact that when the first requirements are stated by the customer, he probably has a rather vague idea of the final process or functionality he needs. In this context the book also focusses on delivery managment, iterative development of user requirements and product delivery and states roles which a team of developers need to take, when wanting to create a so called winning solution.

Need to finish the previous article

2004-11-27T09:04:00.000+01:00

And there it is: sloppyness again. I was going to finish the article on "Threading in a Windows environment" this week but work got me pretty busy. Currently have two projects at the same customer and those keep me busy as hell. Especially since I am the only consultant on the team of my employer SNP at the customers site. The naggy thing is that I am not so much busy coding but more coordinating going-lives of software and stuff.

I really hate all the formal processes you need to go through in big companies. In my opinion processes should be defined to support you work and guide you to do work correcly. However this drastically loses it's sense when because of a complex process involving many parties, you start forgetting what you were originally doing.

Anyhow, this is why I didn't get to finish the entry this week, hope that next week will be better.

Threading in an Windows environment

2004-11-22T16:33:00.000+01:00

Motivation

Every now and then someone drops off a question and zend.com and the likes, asking is multi-threading in a Windows environment would ever be possible. Usually the answer that poor person is getting sounds something like:

"PHP is good for the web and multi-threading is not for the web, since the web is usually about synchronous user dialogs"

In my opinion this is first of all not true: The Web is not just about synchronous user dialogs. It's about asynchronous user dialogs as well, although addmittedly they are not handeled very well by the request-response paradigm which is inheritly synchronous. This is stressed by the fact that no browser I know implements HTTP-Server capabilities and therefore simulating asnychronous processes usually involves JavaScript triggered polling, via page/frame/iframe-reloading or remote scripting.

Why be asynchronous if all you use it for is a progress meter? As far as I (and I guess the majority of end-users) see it. An asynchronous procress is something you trigger and that you them may leave alone on it's own. Eventually you are going to collect a status or some pop-up will show up. Besides the latter case (which would involve polling by the client or a bi-directional connection), asynchronous processes may very well be triggered on the web. And especially when you want your application to process some really long running tasks you will need that functionality.

Currently people tend to tell you, that can execute an external binary or dispatch a request to another daemon - and those things should be written in a stable more daemon-oriented language than PHP, I am saying that for some purposes PHP is well enough sufficient for daemon-type jobs.

If for instance you are writing a newsletter-software which should be capable not only of maintaining newsletters, recipient-lists and such in a database and make those thing accessible via a pretty frontend, but also want to use PHP to do the ground work and send off those emails you will probably have a hard time. Possibly you want to be able to send more than one newletter at a time - so there already you have parallel processing.

Under *nix systems you will probably be quite familiar with pcntl_fork() and all that is around that. "Advanced PHP Programming" by George Schlossnagle - which I like a lot - has a whole chapter about writing daemons in an *nix environment. But what if you'd like to do the same under windows? Well it's ain't quite easy but it can be done - and this is how:

Solution - Overview

The basic idea is about spawning new processes via the command line interface of PHP and keeping communications via a shared buffer (either shared memory or even file based). You will also have to have some interrupt mechanism on the spawned processes to become able to control the process from the outside. While there might be some trap doors along the way, you can still do all you need, even in PHP4 (4.3.0+ if you use debug_backtrace() along the way).

Of course we want to have a nicely playing object oriented way of dealing with the issue, so let's have a abstract class for that. Instances of this class will be used on the parental process to control a spawned thread as well as bear the implementation of the thread as well. In the end we would like to use our thread something Java-like, like this:

// instanciating an implemented WinThread proxy

$thread = &new WinThreadImpl("arg1","arg2","arg3");



// starts the thread

$thread->start(WinThread_ASTHREAD);



// we may set the thread to sleep

$thread->suspend();



// and resume it again

$thread->resume();



// if we don't stop a thread which

// was not started as a daemon explicitly

// the parent script will eventually wait

// for it's spawn to exit before it can

// exit itself

$thread->stop();

Or maybe we would like to create a daemonized thread which can outlive it's parent and is therefore well suited for asynchronous processing. While all of the above control mechanisms work perfectly fine also for this fellow, I would like to introduce some additional ones (which would also work in both cases).

// instanciating an implemented WinThread proxy

$thread = &new WinThreadImpl("arg1","arg2","arg3");



// starts the thread as a daemon

$thread->start(WinThread_ASDAEMON);



// getting the pid of the process

echo $thread->getPid()."\n";



// usually the parent would exit if a daemonized

// thread is not explicitly collected

while($thread->collect()) {

  echo "Thread is still running...\n";

  sleep(1);

}

Solution - Detail

So let's look under the hood of that beast. In the first example naturally the constructor is called first.

/*<WinThread>*/ function &WinThread() {

  $this->_parameters = $this->getConstructorParameters();

  if($this->iAmTheParent()) {

    $this->initializeSharedContext($this->generateRandomId());

  }

}

First the constructor finds out which parameters were passed to it. This is simply a convenience function, which is implemented based on debug_backtrace().
The iAmTheParent() method simply checks based on environment information if it is currently running as the proxy/parent (as it is the case here) or as the thread/child process. In the prior case some shared context buffer is initialized based on a now randomly generated unique identifier. This context will later be used to enable communications between parent and child.

Next the thread is started (in thread-mode; meaning that the parental process waits for the child to exit at the end of it's processing time). The implementation of start() looks like this

>/*<void>*/ function start(/*<bool>*/ $asDaemon = FALSE) {

  if($this->iAmTheParent()) {

    //building command parameters

       $classPath         = $this->getClassPath();

       $constructorParams = base64_encode(serialize($this->_parameters));

       $launchScript      = realpath(__FILE__);

       $execCommand       = WinThread::getInterpreterPath().

                       " \"".$launchScript."\"".

                       " \"launchAsThread\"".

                       " \"".$this->_id."\"".

                       " \"".$classPath."\"".

                       " \"".$constructorParams."\"".

                       " \"".(int)$asDaemon."\"";

    //prefix command if the thread needs to run as a daemon

       if($asDaemon) {

         $execCommand = "start /B ".$execCommand;

       }

    //starting the external process

      $this->_process = @popen($command,"r");

       if($this->_process) {

         //hold as long as the sub process has indicated that it

         //is running by creating one byte of output

         fread($this->_process, 1);

       }

  }

}

First of all the current classpath is fetched. This may be the absolute path to the current class or some other addressing mechanism. Just remember that it is the address of WinThreadImpl not WinThread.
Also the parameters of the constructor which will later be needed in the child process need to be fetched, serialized and packaged so they can be passed along with the command line.
The script to launch is actually the current file (WinThread). As this should encapsulate all technical core necessary for the thread to run. This will actually some executable code aside of the class implementation, which will conditionally be run. It's actually just necessary to have a well known, absolute address which the command line may take as an argument for the callable script that executes the thread.
The $executionCommand, which is now built needs to contain all the information necessary to run the thread. The path to the interpreter can be derived from environment information most of the times. Although this may in fact be a little bit tricky, this is beyond the scope of this article.
The only parameter this script takes which needs to be explained is the literal launchAsThread. This will in the child process be used as an indicator that this is in fact the child process and is the base for iAmTheParent() and iAmTheThread() type methods.
If a process is to be run as a daemon, and thereby be detached from the lifecycle of it's parent, the DOS command start /B may be used to prefix any existing command. start would open a new command-line instance, while the option /B would make it run in the background rather than having a new window popping open.
Finally the command is triggered using the simple popen() instruction, set to read input. This pipe will be used to stop the parent process until the thread has passed it's initialization phase.

Now that we have started the thread from a parent perspective we still need to know how all of this works from the child process perspective.

declare(ticks=2);



class WinThread {



   [...]



   /*static*/ /*<void>*/ function launch(/*<array*/ $argv) {

      if($argv[1] == "launchAsThread") {

      //get command line parameters

         $id         = $argv[2];

         $classPath  = $argv[3];

         $parameters = unserialize(base64_decode($argv[5]));

         $isDaemon   = (bool)$argv[6];

         $className  = WinThread::getClassFromClassPath($classPath);

      //importing/including the required class(es)

         Framework::imports($classPath);

        //instanciate the thread

         $thread     = &new $class($parameters[0],

                                $parameters[1],

                                $parameters[2],

                                $parameters[3],

                                $parameters[4],

                                $parameters[5],

                                $parameters[6],

                                $parameters[7],

                                $parameters[8],

                                $parameters[9]);

        //initialize the shared context

         $thread->initializeSharedContext($id);

        //publish state to shared context

         $thread->publishIsDaemon();

         $thread->publishPid(getmypid());

         $thread->publishIsRunning();

        //enable the interrupt method for this process

         $thread->enableInterrupt();

        //echo one byte so that the main process knows that it's thread has started

         echo "1\n";

        //call the thread implementation callback method

         $thread->run();

        //stopping the thread automatically after it has been processed

         $thread->stop();

      }

   }

}



WinThread::launch($argv);

First we need to declare(ticks=2) so we are later able to plug in interrupt methods using register_backtick_function(). So now the first argument after the script name is launchAsThread is enough indication that the thread should be started. First all parameters that were dropped into the command line call are extracted and correctly interpreted.

[to be continued]

What to bear in mind

This is simplified demonstration code. The real thing works quite nice I can assure you, however there are some details not shown in the presented implmenetation

I am using a programming library that I am putting together now for about 3 years. It lives on a one-class-per-file paradigma. At it's core it has a Java-like mechanism to import classes as prerequisites to other classes. All methods on the Framework-class pretty much state what they do. How the Framework works and how this helps the implementation of design patterns will be discussed in another article

This implementation assumes the existence of a context in the application scope for each thread running. How to implement such a context will be issue of another article. There are basically two efficient variants to do this.
- Shared memory: Using shared memory under windows is currently a tricky beast since you may easily run into the memory-leak trap. However it's easier on you CPU-cycles.
- Files: Using files you have to make sure that you do not corrupt them by concurrent write access or create inconsistent reads. How to easily create concurrency-resistent ressources will be topic of another article.
The usleep() function does not work correctly under Windows until PHP5. And not having it will be a critical hit in performance of other applications since CPU will be used to it's max. There is a workaround using fsockopen() on php.net for windows. But this heavily leaks memory if you try to use it in threads.

Remember that you are actually doing multi-processing here not multi-threading. Sinch each process is spawned completely self-contained, it will consume just as much RAM as it's parental process. This is due to the fact that the PHP runtime and libraries are yet again instanciated for each process.

Reference Coding

Up for now is the reference implementation, that currently exists in my application framework. Don't get confused. Yes, I lean a little towards Java-style syntax.

<?php



//*** begin: launch script *********************************************************************

if($argv[1] == "launch") {

   require_once($argv[2]); //includes the framework if this is run as a stand-alone

   declare(ticks=2);

}

 //*** end: launch script ***********************************************************************



Framework::imports("net.developaz.DAPI");

Framework::imports("net.developaz.context.ApplicationContext");

Framework::uses("php","4.3.0");



declare("WinThread_ASDAEMON",TRUE);

declare("WinThread_ASTHREAD",TRUE);



/**

   @version:   0.1.5



   This abstract class implements 'threads' for windows systems via

   multiple process spawned on the CLI.

*/

/*abstract*/ class WinThread extends DAPI {



   //*** ATTRIBUTES ****************************************************************************

   /*private*/ /*<ref>*/                var $_process;

   /*private*/ /*<array>*/              var $_parameters   = array();

   /*private*/ /*<bool>*/               var $_iamathread   = false; //indicator for thread vs. environment

   /*private*/ /*<ApplicationContext>*/ var $_context;



   //*** CONSTRUCTOR ***************************************************************************

   /**

      The constructor of this thread may be called to construct the

   */

   /*<WinThread>*/ function &WinThread() {

      //$this->_parameters  = func_get_args();

      $arr = debug_backtrace();

      $this->_parameters = ($arr[0]['args'])?$arr[0]['args']:$arr[1]['args'];

      if(!$_ENV['thread']) {

         $this->setId(md5(uniqid(rand(), true)));

      } else {

         $this->setAsThread();

         $this->debug("starting as a thread");

      }

   }



   //*** ABSTRACT METHODS **********************************************************************

   /**

      Abstract method that has to be extended and implements the thread's business logic

   */

   /*abstract*/ /*<void>*/ function run() { }



   //*** PRIVATE METHODS ***********************************************************************

   /**

      Sets a flag that indicates that this is the real instance of the thread and not the stub

   */

   /*private*/ /*<void>*/ function setAsThread() {

      $this->_iamathread = true;

   }



   /**

      Sets the internal ID of the process which is primarily used to identify the correct

      context which is used to access data

   */

   /*private*/ /*<void>*/ function setId(/*<string>*/ $id) {

      $this->_id         = $id;

      $contextName       = "Process.".ucfirst(get_class($this))."Context.".$this->_id;

      $this->_context    = &ApplicationContext::instance($contextName);

   }



   /**

      Publishes the PID of the process

   */

   /*private*/ /*<void>*/ function publishPid(/*<int>*/ $pid) {

      $this->debug("setting pid: $pid");

      $this->_context->set("pid",$pid);

   }



   /**

      Publishes the info that the process is done

   */

   /*private*/ /*<void>*/ function publishIsDone() {

      $this->_context->set("__isStarted",0);

      $this->_context->set("__isRunning",0);

      $this->debug("this thread is done");

   }



   /**

      Publishes the info that the process is running

   */

   /*private*/ /*<void>*/ function publishIsRunning() {

      $this->debug("this thread is running");

      $this->_context->set("__isStarted",1);

      $this->_context->set("__isRunning",1);

   }



   /**

      Publishes the info that the process is suspended

   */

   /*private*/ /*<void>*/ function publishIsSuspended() {

      $this->debug("this thread is suspended");

      $this->_context->set("__isRunning",0);

   }



   /**

      Checks for external instructions

   */

   /*private*/ /*<void>*/ function checkForInstructions() {

      do { //this loop will only be executed multiply if the thread is suspended

         $iterate = false;

         $this->wait(20); //this reduces the instruction rate and actually increases performance

         $instruction = $this->getInstruction();

         $this->debug("checking for instruction... $instruction");

         if($instruction && $instruction != "null") {

            switch($instruction) {

               case "doExit":

                  $iterate = false;

                  $this->stop();

                  break;

               case "doSuspend":

                  $params = $this->getInstructionParameters();

                  $maxMsecs = array_shift($params);

                  $this->publishIsSuspended();

                  $iterate = true;

                  break;

               case "doResume":

                  $this->publishIsRunning();

                  $iterate = false;

                  break;

               default:

                  break;

            }

            $this->clearInstruction();

         }

      } while($iterate);

   }



   /**

      Gets the last instruction for a thread

   */

   /*private*/ /*<string>*/ function getInstruction() {

      return @$this->_context->get("__instruction");

   }



   /**

      Gets the parameters of an instruction

   */

   /*private*/ /*<string>*/ function getInstructionParameters() {

      return @$this->_context->get("__instructionParams");

   }



   /**

      Assigns an instruction for the thread

   */

   /*private*/ /*<void>*/ function setInstruction(/*<string>*/ $instruction, /*<array>*/ $parameters = array()) {

      $this->_context->set("__instruction",$instruction);

      $this->_context->set("__instructionParams",$parameters);

   }



   /**

      Clears the instruction

   */

   /*private*/ /*<void>*/ function clearInstruction() {

      $this->_context->set("__instruction","null");

      $this->_context->set("__instructionParams",array());

   }



   /**

      Sleeps microseconds

   */

   /*incomplete/private*/ /*<void>*/ function wait(/*<int>*/ $msecs) {

      return;

      //$fp = @fsockopen("udp://localhost",31238,$errno,$errstr,$msecs/1000);

      //if($fp) fclose($fp);

   }



   /**

      Returns the microtime as a float

   */

   /*private*/ /*<float>*/ function microtime_float() {

      list($usec, $sec) = explode(" ", microtime());

      return ((float)$usec + (float)$sec);

   }



   /**

      Enables the listener

   */

   /*private*/ /*<void>*/ function enableListener() {

      if($this->isThread() && !$this->_listenerEnabled) {

         register_tick_function(array(&$this,"checkForInstructions"),true);

         $this->_listenerEnabled = true;

      }

   }



   /**

      Disables the listener

   */

   /*private*/ /*<void>*/ function disableListener() {

      if($this->isThread() && $this->_listenerEnabled) {

         @unregister_tick_function(array(&$this,"checkForInstructions"));

         $this->_listenerEnabled = false;

      }

   }



   //*** PUBLIC METHODS ************************************************************************

   /**

      From the host this method starts the thread. If a process

      is started as a daemon it is detached from the parent process

   */

   /*<void>*/ function start(/*<bool>*/ $asDaemon = false) {

      if(!$this->isThread()) {

         $class     = get_class($this);

         $classes = Framework::get("classPaths");

         $classPath = Framework::path2class($classes[$class]);

         $params    = base64_encode(serialize($this->_parameters));

         $launchScript = realpath(__FILE__);

         $framework = str_replace("//","/",Framework::get("root")."/Framework.class.php");

         $command = WinThread::getInterpreterPath()." \"".$launchScript."\" \"launch\" \"".$framework."\" \"".$this->_id."\" \"".$classPath."\" \"".$params."\"";

         //$this->debug($command);

         if($asDaemon) {

            $this->_iamadaemon = true;

            $command = "start /B ".$command." \"1\"";

         }

         $this->_process = @popen($command,"r");

         if($this->_process) {

            fread($this->_process, 1); //hold as long as the sub process has indicated that is is running

         } else {

            $this->setError(2,"could not spawn process");

         }

      }

   }



   /**

      Stops the process

   */

   /*<void>*/ function stop() {

      if($this->isThread()) {

         $this->disableListener();

         $this->debug("stopping itself");

         $this->publishIsDone();

         exit(0);

      } else {

         $this->debug("stopping from outside");

         $this->setInstruction("doExit");

      }

   }



   /**

      Gets the PID of the process

   */

   /*<int>*/ function getPid() {

      if($this->isThread()) {

         return getmypid();

      } else {

         return $this->_context->get("pid");

      }

   }



   /**

      Checks if this instance of the class is the thread itself or the stub in the host process

   */

   /*<bool>*/ function isThread() {

      return (bool)$this->_iamathread;

   }



   /**

      Checks if this instance of the a daemon

   */

   /*<bool>*/ function isDaemon() {

      return (bool)$this->_iamadaemon;

   }



   /**

      Checks if a process is done

   */

   /*<bool>*/ function isDone() {

      $started = $this->_context->get("__isStarted");

      return (bool)!$started;

   }



   /**

      The collecting process waits for a specific sub-process to end

   */

   /*<bool>*/ function collect() {

      if(!$this->isThread()) {

         pclose($this->_process);

         return true;

      } else {

         $this->setError(2,"A thread cannot wait for itself to finish");

      }

   }



   /**

      This method suspends a thread

   */

   /*<void>*/ function suspend() {

      if(!$this->isThread()) {

         $this->setInstruction("doSuspend");

      }

   }



   /**

      This method resumes a thread, that has been suspended

   */

   /*<void>*/ function resume() {

      if(!$this->isThread()) {

         $this->setInstruction("doResume");

      } else {

         $this->setError(2,"This thread is already running");

      }

   }



   /**

      Checks if the current thread is suspend

   */

   /*<bool>*/ function isSuspended() {

      return (bool)!$this->_context->get("__isRunning");

   }



   /**

      Checks if the current thread is running

   */

   /*<bool>*/ function isRunning() {

      return (bool)$this->_context->get("__isRunning");

   }



   /**

      Sets a parameter in the context of the thread

   */

   /*<void>*/ function setParameter(/*<string>*/ $name , /*<mixed>*/ $value) {

       $this->disableListener();

       $this->_context->set($name,$value);

       $this->enableListener();

   }



   /**

      Gets a parameter in the context of the thread

   */

   /*<void>*/ function getParameter(/*<string>*/ $name) {

      $this->disableListener();

      $res = $this->_context->get($name);

      $this->enableListener();

      return $res;

   }



   //*** STATIC METHODS ************************************************************************

   /**

      Sets the path to the PHP-cli interpreter

   */

   /*static*/ /*<void>*/ function setInterpreterPath(/*<string>*/ $path) {

      $GLOBALS['WINTHREAD_STATIC_VARS']['interpreter'] = $path;

   }



   /**

      Returns the path to the PHP-cli interpreter

   */

   /*static*/ /*<string>*/ function getInterpreterPath() {

      $interpreter =&$GLOBALS['WINTHREAD_STATIC_VARS']['interpreter'];

      if(!$interpreter) {

         $php_ini = realpath(get_cfg_var('cfg_file_path'));

         $php_dir = dirname($php_ini);

         if(is_file($php_dir."/php-cli.exe")) $interpreter = $php_dir."/php-cli.exe";

         elseif(is_file($php_dir."/cli/php.exe")) $interpreter = $php_dir."/cli/php.exe";

         $interpreter .= " -c \"".$php_ini."\"";

      }

      return $interpreter;

   }



   /**

      Starts a thread when this class is called as a script from the interpreter

   */

   /*static*/ /*<void>*/ function launch(/*<array*/ $argv) {

      if($argv[1] == "launch") {

         //DAPI::startLogging("log.txt");

         $id         = $argv[3];

         $classPath  = $argv[4];

         $_ENV['thread'] = true;

         $parameters = unserialize(base64_decode($argv[5]));

         $isDaemon   = (bool)$argv[5];

         $class      = substr($classPath,strrpos($classPath,".")+1,strlen($classPath));

         Framework::imports($classPath);

         $thread     = &new $class($parameters[0],

                                   $parameters[1],

                                   $parameters[2],

                                   $parameters[3],

                                   $parameters[4],

                                   $parameters[5],

                                   $parameters[6],

                                   $parameters[7],

                                   $parameters[8],

                                   $parameters[9]);

         $thread->_iamadaemon = $isDaemon;

         $thread->setId($id);

         $thread->publishPid(getmypid());

         $thread->publishIsRunning();

         $thread->enableListener();

         echo "1\n"; //so that the main process knows that this process has started

         $thread->run();

         $thread->stop();

      }

   }



}



//*** begin: launch script *********************************************************************

   WinThread::launch($argv);

//*** end: launch script ***********************************************************************



?>

Welcome to my enterprise applications blog

2004-11-21T19:34:00.000+01:00

Hi folks,

on this blog I am going to spread my thoughts and rants about enterprise application development inside and outside the web-world. While most things that I would like to share are platform-independent most of the implementation example this blog will feature will probably based on PHP (some Java/J2EE and ABAP/SAP) might be included as well.

I guess this blog will grow pretty quickly since this is the stuff I have to deal with at my job all day long and - needlessly to say - need to wine and rant about. So my entries are also not guaranteed to be 100% objective. Maybe I'll be commenting myself sometimes, once I change my opinion about stuff. I am not perfect as is no human being I know and is nothing that is created by a human mind. Therefore solutions which I once promoted may be worn out and replaced over time.

Don't take this blog to seriously as well ;-)