This document follows on from the Embperl/EmbperlObject introductory tutorial.
As you can see from that,
Embperl/EmbperlObject enables extremely powerful websites to be built using a very intuitive object-oriented structure.
Now,
we'll look at some additional,
"unofficial" techniques which may also be useful in certain circumstances.

This is a small collection of personal tricks which I have developed over the course of months using EmbperlObject in my own websites.
I hope they are useful,
or at least spur you on to develop your own frameworks and share these with others.

If you have any Tips & Tricks you want to share with the public please send them to richter at embperl dot org .

In the process of developing a large website I have found it can be a little onerous at times to use the Request object to pass around global data.
I would like to just create variables like $xxx rather than typing $req->{xxx} all the time.
It may not seem like much,
but after a while your code can start looking a lot more complex because of all the extra brackets and suchlike.
As a typical lazy programmer,
I looked for a way to simplify this.

The method I am going to describe should be used with caution,
because it can increase memory useage rather dramatically if you're not careful.
The way I use it,
no extra memory is used,
but you do need to be aware of the issues.

Basically,
you change the way you include files from /base.html,
so that they are included into the same package as /base.html:

[- Execute ({inputfile => '*', package => __PACKAGE__}) -]

You should only do this with HTML files which are included from /base.html, not with the files such as subs.html - those files have to be in their own packages in order for Perl inheritance to work. You can't use this technique with any files which are accessed via method calls.

So how does this make things better? Well, since all these files now share the same package, any variables which are created in one of the files is accessible to any of the other files. This means that if you create $xxx in /init.html, then you can access $xxx in /head.html or any other file. This effectively gives you global variables across all the files which are included from /base.html into the same package as /base.html.

The thing you need to be careful of here is that if one of these files is included more than once elsewhere on the website, then it will be seperately compiled for that instance - thus taking up more memory. This is the big caveat. As a rule, if your files are all just included once by /base.html, then you should be fine. Note that you'll also need to change any calls to parent files, for example:

This is ok, since ../init.html will still be compiled into the same package as the rest of the files included from /base.html, and so only one version of it will exist in the Embperl cache. Thus memory usage is not increased.

I like this technique because it simplifies the look of my code, which is important for projects containing complex algorithms. It is not the "official" way to implement globals though, and should be used with care.

The previous section described a way to share variables between different files which are included from /base.html, by using the same package across all the files. However this doesn't help us much when dealing with the method files such as subs.html, because these files have to have their own packages - so we are back to square one.

There is another way to share variables across even different packages, and that is by using namespaces. For variables that need to be accessible even from subs.html, you could use a namespace which is specific to your website. For example, if your website domain is mydomain.com, then you could create variables using the form

$mydomain::xxx = "hello";

As long as you then make sure that you only use this namespace on this website (and other websites on the same Apache web server use their own namespaces), then you shouldn't get any conflicts. Once again, use this with caution, since you introduce the possibility of inadvertently sharing variables between completely different websites. For example, if you cut and paste some useful code from one website to another, you will need to make sure you change the namespace of any globals. Otherwise, you could get some very obscure bugs, since different requests to the various websites could conflict.

You also need to be careful about variable initialization, since these globals will now exist between different requests. So, it's possible that if you don't re-initialize a global variable, then it may contain some random value from a previous request. This can result in obscure bugs. Just be careful to initialize all variables properly and you'll be fine.

Finally, note that Embperl will only clean up variables which don't have an explicit package (i.e. are in one of the packages automatically set up by Embperl). Variables in other namespaces are not automatically cleaned up. As a result, you need to pay closer attention to cleaning up if you use your own namespaces. The safe way to clean up a variable is simply to 'undef' it.

If you are like me, you probably use DBI extensively to enable your dynamic websites. I have found the cleanup of queries to be onerous - e.g. calling finish() on queries. If you don't do that, then you tend to get warnings in your error log about unfinished queries.

What I do these days is use a global hash, called e.g. %domain::query (see the previous section for using namespaces to safely implement global variables). Then, whenever I create a query, I use this variable. For example:

This little pattern, I find, makes all my queries easier to read and keep track of. You give each one a name in the %domain::query hash that makes sense. Then, at the end of each request, in the /cleanup.html file, you can do something like this:

Once again, this method is not really the "official" way of doing things in Embperl. You should use the Request object to pass around global variables if you're not comfortable with the risks involved with namespaces (e.g. conflicting websites on the same web server).

You will often find that you want to terminate a page before the end. This doesn't necessarily indicate an error condition; it can be just that you've done all you want to do. When you do this, it is good to first clean up, otherwise you can get annoying warnings showing up in your error logs.

I use the following framework. /cleanup.html is Executed from /base.html, and it is the last thing that is done. It calls the cleanup() function in the /subs.html file:

The EMBPERL_OBJECT_FALLBACK directive in httpd.conf allows you to set a file which will be loaded in the event that the requested file is not found. This file should be relative to the same directory as base.html.

I have found that making a special /errors/ directory is useful, because it enables that special subdirectory to define its own head.html file, init.html and so on. So, I then just put this in /notfound.html:

When I am developing a website, I usually use at least two machines. I have a workstation where I do developing and testing, and a separate production server, which is accessed by the public. When I am finished making changes to the development version of the website, I move it over to the production server for testing there. However when I do this, I usually don't copy it immediately over the existing production version, because there are sometimes issues with Perl modules which haven't been installed on the server, or other issues which break the code on a different machine. So I use a separate virtual server and subdomain (which is easy if you run your own DNS) to test the new version. For example if the production version of the server is at www.mydomain.com, then I might do testing on the production server under test.mydomain.com, or beta. or whatever subdomain you like. This means you have to create a new virtual server in the httpd.conf file. You also obviously create a new directory for the test server (see below for an example).

When you do all this, you end up with a very nice, isolated testing environment on the same server as production. Obviously you hopefully did all your major testing on your workstation, where you can crash the machine and it doesn't matter too much. The production server testbed is a last staging area before production, to get rid of any lingering glitches or omissions. When you're sure it's all working correctly you just copy the files from one directory tree (test) to another (production) on the same machine. This test server can also be used as a beta of the new production version. Friendly users can be given access to the new version, while the old version is still running.

One issue that comes up when you do this is that of databases. It is very likely that you will be using a special test database rather than the live one to test your new version. It would be very unwise to use a production database for testing. So your production database might be called "mydatabase", and the test one called "mydatabase_test". This is fine, but it means that you have to remember to change the database name in your code when you copy the files over to production. This is very error prone. The solution is to set variables like the database name in httpd.conf, by setting an environment variable. You just add it to the virtual server section.

Here is a real example of two virtual servers on the same production machine, which use two different directories, separate log files and different databases. The website is crazyguyonabike.com, which is a journal of a bicycle ride I did across America in 1998. I decided to expand the site to allow other cyclists to upload their own journals, which resulted in substantial changes to the code. I wanted to keep the original site up while testing the new version, which I put under new.crazyguyonabike.com. Here are the relevant apache settings:

Note that the test and production servers each get their own databases, directories and log files.

You can also see that I restrict access to the test server (which is generally wise, unless you actually like hackers potentially screwing with your head while testing). For basic authentication I use mod_auth_mysql, which is available from the MySQL website. It is nice because it allows you to authenticate based on a MySQL database.

When you use PerlSetEnv to pass in variables, you access these variables in your code as follows:

$db_name = $ENV{WEBSITE_DATABASE};

If you move those constants which differ between the test and production versions of the same code into the httpd.conf file, then you can just copy the files over from the test directories to the production directory without any alterations. This cuts down on editing errors and also documents specific constants in one place.