I have ended up with a very old piece of hardware and of course the first thing I did was wipe the Windows 2000 installation and stick a few versions of Linux on it. Unfortunately it only came with 128MB of memory from factory so nothing would run very well. The PCMIA wireless card that came with it wouldn’t work with WPA2 under Windows 2000 so an upgrade was required.

£5 later I got a matched pair of Crucial 256MB sticks on ebay so I could try out Linux Mint 6 Fluxbox edition and Linux Mint 10 LXDE. Whilst both worked right out of the box I did have to configure the X11 monitor settings so that it would support the full 1024x768 splendour that the Inspiron 2500 affords you. See the gist I have setup on github for my configuration file and some short instructions on getting it setup.

In the end I decided to go with Mint 10 LXDE as it used a similar level of system resources, but ran more smoothly and of course benefited from being the latest version with full package update support.

I expected to have a load of issues getting the Belkin wireless adapter working, but in the end this distro had all the drivers so need for all those ndiswrapper recipes that are out there. It is running much better than the Windows 2000 OS was as well and benefits from having and running newer versions of all the applications I need.

Of course web streaming of Flash video is somewhat staccato with such a small CPU but it is a perfectly usable web browser and word processor.

A project I am working on at the moment requires time delayed job queues and having found nothing yet that can manage it properly so I decided to wrap up `at` into a PHP class. This gives you simple methods to add, list and remove jobs from the `at` queue using object oriented code.

The code is very simple and I have documented it reasonably well so along with the examples you should get on your way quickly. The class can, of course, be used from the command line as well so if you want to write batch scripts in PHP to handle adding a collection of predefined `at` jobs for example - it can make it easier.

I feel the important features of `at` have been added into the code, but if you want to wrap any of the other functions then please do fork my code and make a patch or post a pull request. For more information on what `at` can do please either run `man at` in your console or visit the Edinburgh University’s man at page.

You can get the code from my repository on GitHub: PHP-at-Job-Queue-Wrapper.

If you do have any trouble getting the `at` daemon (atd) going then my previous post may help you debug it - please see If you are having problems getting Ubuntu atd running for more on that.

If you just cannot get atd to start running check the permissions on your /var/spool/cron/atjobs and /var/spool/cron/atspool directories. The should be `chmod 770` and then `chmod +t`. Also they should be owned by `daemon:daemon`.

I was getting this error when attempting to set new at jobs:

Can’t open /var/run/atd.pid to signal atd. No atd running?

If I tried to start the daemon through the service management I was getting:

sudo service atd start
start: Job is already running: atd

But running `ps -elf | grep ‘atd’` yielded no appropriate results.

When trying to start the atd daemon manually on the command line I was getting:

simon@forge:~$ sudo atd -d
Cannot change to /var/spool/cron/atjobs: Permission denied

Which finally gave me the clue!

As you have found this page I am sure you have accidentally hit the control+s short cut whilst inside a PuTTY shell and following that no keystrokes appear to affect the session. Basically hitting ctrl+s causes PuTTY to stop executing the stream coming in from the keyboard. It does however still listen to your keystrokes and it basically adds them to a queue.

Hitting control+q will re-open the stream execution, but it is worthwhile noting that it will also execute all the queued up commands as well!

So far I have tried out Ubuntu, eeeBuntu, EasyPeasy Linux and CrunchBang Linux (all of which are Debian based) on the Asus Eee PC.  Ubuntu was a bit of an annoyance to get setup and it was troublesome trying to get all the buttons or the sound and microphone to work so I then tried EasyPeasy.  It was easy to install (it already contains the Array.org kernal) and I liked the NBR interface with its easy to use tabbed system not to mention that after using Ubuntu it was nice to be able to see most of the system dialogues on screen (Ubuntu’s dialogues were so long they fell off screen! – Hint: hold down alt and click to move dialogues without titlebars).  The major problem I had with it was that it took way too long to boot and came preloaded with a whole host of applications I will never need.

So after some research I saw a lot of good things being said about eeeBuntu, which again in the version I chose uses the NBR interface.  Also whilst it was very nice to use not everything worked, which was very annoying.  The microphone and some of the shortcut buttons did not work, which is useless if you need to use Skype.  The selection of preloaded applications was also not to my tastes (although better than EasyPeasy) and boot time was also quite painful although not as bad as EasyPeasy.  Speaking of boot times make sure you remove any SD cards from the onboard slot before booting the machine as this will add significantly to the load time of the OS.

After using eeeBuntu for some time I finally grew tired of the lag and decided it was time to do some more research into the available packages for easy installing on the Eee PC.  This is when I came across CrunchBang (#!) Linux, which is a very light weight version of Ubuntu running the Openbox shell.  This distro boots quickly, comes with a nice set of applications that I can easily build upon.  I am really pleased with the OS so far and I am even writing this post from within it.

Installation is very simple just use UNetbootin to transfer the Cruncheee image to a USB key and boot from the USB key to try out the ‘live disc’ version of the OS to see if it is for you.  If you like it then right click on the desktop and choose install from the resultant menu.

Not everything will work right of the box though.  The microphone does not record immediately and requires some tweeking to the Volume Control interface.  You can bring up the interface by pressing the shortcut Super + v (in my case the Super key is emblazoned with the Windows logo).  Now click the preferences button at the bottom of the dialogue and check the boxes beside Front Mic Boost, Capture and Input Source.  Now in the playback tab unmute Front Mic and raise the volume, on the recording tab unmute the microphone icon and raise the volume and finally on the options tab choose Front Mic from the drop down.

Unfortunately there is one further annoyance.  The volume buttons do not bring up the on screen display but Super + v will bring up the mixer which is fine for me at the moment.

Sun VirtualBox Logo

Often Linux just does it better!  Often I find myself developing a Windows machine without access to a Linux development server, but I still need to access to some of the Linux binaries and features such as cron jobs, the at command and binaries such as imagemagick, pdftotext, etc.  Some things can be emulated with ported binaries or through Cygwin, but I feel a lot more comfortable developing on a platform that is representative of the live server the web site will run on.

I have not removed XAMPP as it is very useful for developing small scripts or sites without the overhead of running a virtual machine.  Therein lies the problem with this solution – it is virtual machine based and that will mean your local development machine will suffer when the virtual machine steals computing time from the CPU or more memory.  So whilst I can use XAMPP on my netbook I am not so sure a VM will run smoothly.

Setting up a new development environment

1. Download VirtualBox 2.1 from http://www.virtualbox.org
2. Download the latest Ubuntu from http://www.ubuntu.com
   Your choice of server or desktop. I chose desktop to give me another web browser testing environment.
3. Install VirtualBox and open it up
   1. Click create new VM (Virtual Machine)
   2. Give your VM name (I called mine Development)
   3. From the drop downs choose
      1. Linux
      2. Ubuntu (only choose Ubuntu 64 bit if you are running 64 bit Windows)
   4. Choose how much of your machines physical memory the virtual machine is allowed to steal. I chose 512MB as I am running the desktop version of Ubuntu.
   5. You will need to create a new virtual hard disk – a new hard disk wizard will open
      1. Choose dynamically expanding storage
      2. Choose
         1. Give the virtual hard disk a name (mine is called Development just like my virtual machine)
         2. The location of the storage on your hard drive
4. Now your new virtual machine should be setup so right click on it and choose Start
   1. The Virtual Machine will pop up a message asking you to go through its first run wizard
   2. Choose your installation location
      1. CD/DVD ROM
      2. Image file – point this to the location of your Ubuntu installation ISO you downloaded and saved earlier
   3. This will then mount your CD image and boot from it
5. Install Ubuntu by going through its installation wizard which is very easy and does not require detail here (if you have chosen the desktop version this will be even easier because you can use the mouse!)
6. Once you have the virtual machine setup you will want the nice Linux drivers so you can have a larger screen size and for networking etc. For this you need to install the Virtual Guest Additions.
   1. Mount a new CD drive/ISO Image in your virtual machine whilst it is running from the top menu item called Devices
   2. Add the new image which you will find in your VirtualBox program folder
7. Back to your virtual machine and open up a terminal window
   1. In your terminal navigate to the CD Rom drive
   2. Execute the following command sudo sh ./VBoxLinuxAdditions-x86.run
   3. Once complete you need to reboot the machine so execute sudo reboot
8. Once the machine reboots get back into the terminal and run the following commands
   1. sudo apt-get update
   2. sudo apt-get upgrade
   3. sudo apt-get install apache2 mysql-server-5.0 php5 php5-xdebug
   4. Just to be on the safe side restart apache with sudo /etc/init.d/apache2 restart
   5. Try accessing your web server by opening a web browser in the virtual machine and typing in localhost if you chose the desktop and you should see a message like It Works!
9. We need to be able to see folders on our host machine inside the development machine quickly and easy so from the top menu bar choose Devices -> Shared Folders
   1. Add a new folder
   2. Tell it which folder to look in
   3. Give it a memorable name
   4. Tick make permanent
10. Jump back into the virtual machine and execute the following commands to add your shared folder to the virtual machine, in a terminal
    1. sudo mkdir /mnt/yourFolderNameHere (mine is /mnt/htdocs/)
    2. sudo mount -t vboxsf memorableFolderName /mnt/yourFolderNameHere
       1. Replace memorableFolderName with name you set in step 9.III
       2. Replace /mnt/yourFolderNameHere with the folder you made in step 10.I
    3. If you navigate to /mnt/yourFolderNameHere and execute ls you should see a list of the files on your host systems shared folder
    4. If that worked then we want to add our folder to the fstab file so that the mount point is loaded every time our virtual machine boots up
       1. sudo vim /etc/fstab
       2. Add the following line to the bottom of the file:
          memorableFolderName /mnt/yourFolderNameHere vboxsf defaults 0 0
          1. Replace memorableFolderName with name you set in step 9.III
          2. Replace /mnt/yourFolderNameHere with the folder you made in step 10.I
11. Now to make this development machine available over the network shut the virtual machine down by going to top menu bar Machine -> Close and choosing Power Off
    1. Right click on the virtual machine and choose settings
    2. From the left hand menu choose Network
       1. Tick Enable Adapter
       2. Adapter Type: Intel PRO/1000 T Server
       3. Attached to: Host Interface
       4. Tick Cable Connected
       5. Choose the interface on your host machine that gives you access to the outside world. You can find out which one this is by looking in your control panel.
    3. Save the settings and start your virtual machine back up again
    4. To find out the IP address of your virtual machine open a terminal execute ifconfig
       
12. You should now be able to visit your web server from your host machine by entering that IP address into your web browser.
    

Configuring our web server

1. We need to enable mod_rewrite which involves making a simple symbolic link
   1. Navigate to /etc/apache2/mods-enabled
   2. Execute sudo ln -s /etc/apache2/mods-available/rewrite.load rewrite.load
2. Reboot the server sudo /etc/init.d/apache2 restart and test it is function ok.

Setting up Mass Virtual hosts

The idea behind this step is to minimise the time it takes to setup a new host on the server. Basically all you have to do is create a new directory an away you go. (Don’t forget it will still need to appear in your hosts file).

1. We need to enable mod_vhost_alias
   1. Navigate to /etc/apache2/mods-enabled
   2. Execute sudo ln -s /etc/apache2/mods-available/vhost_alias.load vhost_alias.load
2. Now to setup the rules it will create virtual hosts by
   1. Execute sudo vim /etc/apache2/apache2.conf
   2. Go to the base of the file and add the following rules:

      http://gist.github.com/294736

      VirtualDocumentRoot sets the directory that the VHosts public directory is contained in. This will basically convert http://subdomain.localhost/ to /mnt/htdocs/subdomain and pull the relevant files through.

3. Now restart the apache process sudo /etc/init.d/apache2 restart

A side note when using this method that you should be aware of. This will affect your rewrite rules if they are placed into a .htaccess file. To avoid any problems always declare the RewriteBase rule in your .htaccess.

For example:

http://gist.github.com/294737

VirtualBox Shared Folders Permissions

Nathan brought a glaring omission from my post to the fore – thanks!  Currently you maybe having permissions issues with your shared folders because they might be being mounted as root:root.  To get them to load with a specified user and group you will need to edit your /etc/fstab file again and change ‘defaults‘ to be ‘uid=username,gid=groupname‘ – an example would be ‘uid=simon,gid=www-data‘.

A full line example would be from:
htdocs /mnt/htdocs vboxsf defaults 0 0
to
htdocs /mnt/htdocs vboxsf uid=simon,gid=www-data 0 0

In the PHP development arena the LAMP (Linux, Apache, MySQL and PHP) stack is very common, but once in a while a client will come through the door with a Microsoft background. So what do you do if your CMS or framework was built with a Linux base layer in mind? Sounds easy, but what if you have jobs loaded into your Linux crontab for processing mail outs or after hours records processing?

There are options for implementing cron jobs with a Windows server, one of which is to offload your cron jobs to a Linux server and use WGet to remotely activate the processing script on the Windows server. For more information on setting up cron jobs on a Linux box please see Introducing Cron. Whilst this does work well, what if the Linux box goes down or its internet connection is severed and your scripts on the Windows server do not run? Or perhaps you do not have a Linux box to hand or you don’t feel comfortable sending cron job requests across the web.

Well you are in luck because Windows does offer a way to run cron jobs although its termed Scheduled Tasks by Microsoft. You will also need a small Windows binary that performs all the functions of the Linux WGet programme. I use the WGet for Windows utility compiled by Christopher Lewis. I usually stick it into the Windows Programs Files directory, but you can put it anywhere you like.

You might be thinking to yourself why use WGet when the box already has Internet Explorer and Mozilla Firefox installed; surely they can open a web address? Well, yes, they can but every time the task/cron job is invoked a new instance of the browser is created. Once the cron job is complete they do not self close either so your server would be left with many useless open processes running! No good at all.

Now we have the necessary software installed lets turn our attention to the setup of our Scheduled Task and as usual Windows has a nice wizard interface that can be found by accessing Start > Programs > Accessories > System Tools > Scheduled Tasks. However if you prefer the command line I go into detail further down the article about using schtasks.exe. When you open the utility you will see a Windows Explorer window containing any pre-existing tasks and an “Add Scheduled Task” icon which is the one we want to double click.

Let us step through the wizard setup process:

1. Click next on the introduction page.
2. Choose the programme you would like run your PHP script. This is where the WGet binary comes into play. Use the browse button to locate it. Click next.
3. Give your task an easily identifiable name and choose the regularity with which you want the task to run. As an example you might use once a day for a mail out script and once a week for a database backup script. Yep you guessed it; click next.
4. You will be presented with a screen giving you more in depth scheduling options where you can choose start time and date and what days, weeks or months of the year you want the task to run on. Once again, after you are done, click next.
5. You must now choose a user that the task will run as and enter the username and password. I always setup a new Windows user solely for running Scheduled Tasks and I recommend you do the same for securities sake. As it is outside the scope of this article I will assume you know how to setup Windows users. You get the idea by now I am sure; click next.
6. A summary screen will then be displayed and we need to check the “Open advanced properties for this Task when I click finish” checkbox.
7. You will arrive on the Task tab of a window that looks much a like file properties window where we need to adjust the contents of the Run field to tell WGet which script we want it to run. Don’t delete the contents of the field just add the URL to your PHP script on the end. So you should end up with something like this: “C:Program Fileswgetwget.exe http://www.yourdomain.com/your_script.php –spider”. The ‘–spider’ switch on the WGet binary causes it to behave like a web spider effectively pinging the file to see if it is there without downloading it (don’t worry the spider request will cause your script to be run). For more information please see the WGet manual.
8. On the Schedule tab you can change the regularity of the Task with more granularity using the Advanced button and you can have multiple schedules for the same Task.
9. On the Settings tab I would set the Task to Stop if it runs for: 00 hour(s) 1 minute(s) unless you are running an intensive routine.
10. Click OK

Once back viewing the Scheduled Tasks folder you can right click on the Task and choose Run to see if it works as expected.

OK so that is great if we know what tasks we want to setup, but what if your system needs make its own Tasks on the fly or you prefer setting up Tasks via the command line. Obviously you need to be exceptionally careful when you allow a web accessible script to setup Scheduled Tasks just as you would with cron jobs.

You must be running your server on a Windows system with Server 2003, Server 2008 or XP Professional otherwise you will not have the required schtasks.exe executable. To find out if you have it run schtasks on the command line. It should return a list of Scheduled Tasks currently on the system and if you see this read on otherwise you will need to investigate the windows at utility (type at /? on the command line).

The best place to start is by running schtasks /? which will bring up the help manual, but for further information on creating a Scheduled Task you should also read schtasks /Create /?. As there are lots of confusing options there I will break it down for you with a brief example.

http://gist.github.com/294734

In the above statement we are creating a new Scheduled Task that is to run every five minutes and it executes WGet, which in turn calls our PHP script. /RU and /RP are the username and password (respectively) of the account that will be used to run the task and /SC is the definition of the iteration interval which can be from minutes to monthly. The /MO is the modifier which determines when it runs, in our example above its every 5 minutes, /TN is predictably the unique name of your Scheduled Task and /TR is the command to be run when the Scheduled Task is activated.

As another example if we wanted a script to be run every second month we would enter something like this:

http://gist.github.com/294733

So that should give you a basic idea of the command line utility and adjusting the examples with the help of the manual available by typing schtasks /? and schtasks /Create /? should get you on your way.

If you are like me you are now wondering if I am recommending security via obscurity; absolutely not! The problem with the examples I have given above is that if someone were to guess the URL of your processing php script (http://www.webaddress.com/script.php in the example above) they could access it via their web browser. Now think of the ramifications if your script is meant to send out emails once a day, but instead your script gets hit by a bot and sends your users 1,000+ emails a day!

So to lock your scripts down a bit I recommend the following:

1. Always check the IP address and user agent of anyone trying to access your script
2. Add an HTTP header to our request so we can pass our processing script a secret key

These checks combined should halt any bots in their tracks. So let us take a look at how this would work in real life with the following example code. Firstly the call we would issue to Scheduled Tasks and WGet:

http://gist.github.com/294735

–header=TASK_KEY:my-secret-key tells WGet to add an HTTP header called TASK_KEY which contains the value of “my-secret-key” to its request for the processing script. We can then compare the contents of this header with the copy of the secret key in our processing script – this will make more sense when I show you the PHP side of the coding. You will also notice that I have added -U my-agent, which changes the user agent that WGet identifies itself as – in this case to “my-agent”. Obviously you would want to change the key and user agent to make them harder for a bot maker (who could be reading this) to guess. I would use a SHA1 hash for your secret key just to make it even harder to guess – it is a lot harder to luck upon a94a8fe5ccb19ba61c4c0873d391e987982fbbd3, which is the word test hashed rather than simply the word test.

The PHP side of this is also very simple:

http://gist.github.com/294731

So again you can see here that you need to change the values of “my-agent” and “my-secret-key” to your own private values. Now to break down the code by looking at the operations in the if statement.

The first line ‘my-agent’ !== $_SERVER[‘HTTP_USER_AGENT’] checks to see whether the value of the user agent matches the specified value “my-agent”.

The second line $_SERVER[‘SERVER_ADDR’] !== $_SERVER[‘REMOTE_ADDR’] checks that the server requesting the script be processed is the same as the one the script is being executed on. Basically this means that only requests coming from the same IP address as the server will be run.

The third, fourth and fifth lines:

!isset($_SERVER[‘HTTP_TASK_KEY’]) or
empty($_SERVER[‘HTTP_TASK_KEY’]) or
‘my-secret-key’ !== $_SERVER[‘HTTP_TASK_KEY’])

Check that the HTTP header has been set then if the header contains something and finally if the header contents match our secret key; “my-secret-key” in this case.

If any of the criteria are found to be missing then the script will display the message “You do not have permission to execute this script!” and halt otherwise the code placed after the end of the if will be executed. So in this example upon a successful run the script would print out “Executing operation”.

Before I go I shall also very briefly show you how to setup a Scheduled Task from a PHP script. This can be very useful if you have a very large list of emails to send out to and the PHP script times out whilst your Scheduled Task is executing. What you can do is split it up into job lots of say 500 emails at a time and schedule the send out as multiple Scheduled Tasks dynamically from PHP. Of course this same principle would apply to large dataset changes that timeout during their operation as well.

To dynamically schedule the task we simply send it to the system via the PHP exec() function. As I said earlier you must ensure that you are very careful of what you put in an exec() call and I would advise that no user supplied data is allowed lest they maliciously insert a command like format C:! Here is the basic PHP to work from:

http://gist.github.com/294732

The only new concept here is that I always make sure I delete any Scheduled Task that may already be in place with the same name before attempting to setup the new Scheduled Task.

To summarise we have now got a Scheduled Task up and running with some security to ensure only our server is able execute the processing script. You have learnt how to setup a new Scheduled Task either via the command line or the graphical user interface wizard or via the exec() function in PHP to dynamically setup new Scheduled Tasks on the fly. Experiment further and enjoy!