I’ll be documenting here in my blog exactly the steps needed to take it from a tabula rasa to my perfect desktop system.  Apart from the system being obviously Linux based, there will be a number of things to consider before I get started. If I want it to be perfect, I need to think about what it is that I really need and want from a work only system. So, after a brainstorm this is the breakdown of what I require:

1. Keyboard Friendly

   I am becoming less interested in using the mouse. This is for a number of reasons, firstly it is quicker to keep your hands on the keyboard rather than always having to find the mouse and point and click. Secondly, using the mouse greatly exacerbates RSI and all that jazz. As such a system designed for maximum keyboard usage is important.

2. Great Web Development Tools

   As a web developer this is a no brainer. I need to be able to have the tools for developing websites, testing (at code, server and client level) deployment and client side version control.

3. Base system should be small, quick and light

   Due to point 2, I can see the need for being able to have virtualised instances of Windows running, each running a different version of IE. As such, the base system should be as small, quick and light as possible so it doesn’t get bogged down when I have one (or more) windows running for testing purposes.

4. Communications

   I have to be able to email, chat, and talk with people via my computer

5. Music and sound

   I need to listen to music at work!

6. Must get on with others

   Some strange people out there still use propriety software. My system needs to be able to read Word and Powerpoint and all that stuff.

7. Not be rude

   This is a strange request, but over the weekend I had a friend staying who is an IT administrator for a large international company. He had to do some work on their Windows based infrastructure, so he powered up Vista on my laptop (which I never use*) to log into their systems via the Remote Desktop. Half way through he had to make a couple of calls. When he came back Vista had rebooted and he had lost everything. We narrowed it down to the fact that Vista had updates, installed them and rebooted without even asking for permission. IMO, that is really fucking rude.

8. Stable

   Last, but by no means least, the system has to be solid. I can’t have it crashing on me every hour.

And that is pretty much it. Follow me over the next week or so whilst I sort out my ideal perfect work station.

* I just had to make that point

Building My Perfect Desktop

• Day 1 – The Base System
  

The internet is great! Clearly it wasn’t just me having a problem, Guido Stevens was also suffering and posted a fix, which he himself found on another blog post by Chris Miller, which Chris in turn found on StokeBloke.com which had been found originally on a now dead post.

Not bad! Four people all having problems with the same thing and posting a fix for others to share. So I thought I’d join the chain, and write this blog post.

Oh yes, and the fix itself:

;; fix css mode
(require 'css-mode)
(setq cssm-indent-level 2)
(setq cssm-newline-before-closing-bracket t)
(setq cssm-indent-function #'cssm-c-style-indenter)
(setq cssm-mirror-mode t)

How did it go?

To start off it was slow. Emacs has a notoriously high learning curve, and I pretty much started at the bottom. One of the reasons for doing this was so I could move away from the mouse and it turns out that the mouse is an extremely hard habit to break. So to are the keyboard arrow keys. I kept on finding my hands would instinctively  jump off the keyboard and try to double click on something, or try to navigate around the page with the arrows. This is clearly not the way it is done in Emacs!

The next thing I found is that Emacs doesn’t let you indent code files as you want. It seems to have a preferred method and forces it on you. This is very annoying and being a n00b I still haven’t found a way around this.

However, after a couple of days I began to get the hang of it. Still painfully slow, but navigating around the page, buffers and windows was becoming gradually quicker. I began to enjoy using Emacs, even though my right hand kept on unceremoniously lurching to the right from time to time.

By a complete coincidence, on Wednesday I was invited to C-Base here in Berlin for a beginners’ introduction to Emacs. Even though it was all in German, and my Deutsch ist nicht so gut I was blown away by not only the speed but also the huge amount of functionality within Emacs. To see someone who actually knew Emacs inside out was a revelation. I made a huge amount of notes (within Emacs before you ask!) ready to test out for myself. This insight into the “how the pros use Emacs” has really been an eye-opener and I am determined to learn just a fraction of what was on display at the tutorial.

Summing up my week with Emacs.

It was hard work, there was much and is even more left to learn. It is a vast landscape to negotiate, with many nooks and crannies. But once it is mastered I have no doubt that my productivity will be greatly increased.

Other people diving into Emacs

• Stephen O’Donnell – Choosing an Editor
• John Bokma – Emacs it is
  

Some useful sites

• http://www.gnu.org/software/emacs/manual/
• http://www.emacswiki.org/
• http://emacsblog.org/

For us at ibrow, the number one practise that we engage in is Version Control/Revision Control. I personally use version control for almost everything and not using it when having multiple developers working on a project sends shivers down my spine.We currently use Subversion, however I’m thinking of moving over to Git, but there is also Bazaar and Mercurial plus many, many others.

Whilst there is this vast array of version control system for code, there doesn’t seem to be the focus on version control for database schemes. Jeff Atwood has a couple of posts espousing the virtues of version control for databases. There is Rail’s Migrations which seems to be the most advanced version control for databases to date and there is a project to make a PHP version of Migrations. However, Migrations still has it’s flaws, which are discussed in Adam Wiggins’s blog post about this very subject. Adam offers some good insights into the problem and has a brain storm about possible solutions. But I think I’m coming to the problem from a slightly different angle to him.

As most of our projects are in constant development we do not, as such, have versions, but instead revisions. This is a key difference here. If we check in a database change to the version control, we don’t yet know it’s revision, especially if we have multiple developers working on the same project and possibly changing the scheme of the database at the same time.

The ideal solution would use the following steps:

1. Developer finishes their chunk of code with any database changes, and are ready to commit. The database changes include UP and DOWN changes.
2. Developer commits their code changes, a revision number is assigned
3. Based on this revision number, the database changes are committed.

Obviously the developer should update their working copy before committing, just to see if there are any conflicts and to make sure they have the latest copy of the code.

On the updating side, the following steps should occur when the developer updates their  code:

1. The update process makes a note of their current revision number
2. Downloads all code changes via the SVN update command
3. Downloads all the database changes since their last revision
4. Update process applies all database changes to developer’s local database

This process can be reversed for reverting or merging backwards.

Currently I can’t find anything out there that does this – which probably means one of 2 things:

1. My Google-fu isn’t up to scratch
2. It is actually a lot harder than I think!

I really need to get this right, as this is possibly the most important thing to get right for us at the moment. It would be great to hear any possible solutions or existing implementations out there.

Maybe this will be an interesting sub project for me over the next few weeks?

(And obviously I haven’t even considered trying to keep the data up to date – but I guess that will be for another day.)

So why?

Well, let me first state that Sup is no where near perfect. Crazy people out there still send me HTML email which obviously doesn’t display too well in a command line interface, but I can open those up in my browser. I still haven’t found a way to easily search and add multiple names from the address book to an email I’m composing. And there is that irritating thing that means if I’m writing an email, I can go back and view my inbox (note: this is probably my fault, I’m using a popup window’d emacs).

But the thing is these are all fixable. It is open source, so if these things really pissed me off then I should learn Ruby and have a crack at fixing them myself. And the thing is I like Sup so much I just might.

Also Sup is being actively developed. If you have a look on the Gitorius page you can see that Sup’s maintainer William Morgan seems to spend every weekend hacking away! Plus there is a large list of active developers.

Yet I didn’t move all my mail accounts over to Sup just because I can fix things and if I can’t then hopefully someone else will!

No, I moved them all over because Sup appears to be slowly, email by email, saving my life.

I currently have 1893 emails index, but of these 1893 email, only 12 of them are in my inbox. For me this is unheard of.

Sup has provided me with such an easy system of filing and organising my mail that I can deal with it pretty much instantly, clearing my inbox. And over the last month I have found that keeping a clean inbox keeps my head pretty focused. I’m not worrying about all the emails I have to deal with. I am finding I can handle more stuff, get more stuff done and still have a tidy head.

This is great news!

Having this confidence of being able to handle more stuff, I’m wanting to handle more stuff. I want to do more things, I want to push projects forward. I am now no longer wallowing in an unorganised mess! So thank you William and thank you Sup – you are saving my life

More stuff? Bring it on!

More Sup posts

• Sup, OfflineIMAP, MSMTP on Jaunty
• Fixing a Sup Crash

Sometimes I really love the Linux world. Sometimes it all fits so neatly together and lets you just get stuff done. Sure it might take a bit of digging around, but when it all comes together it really is beautiful!

I’m waxing lyrical today because I have just managed to fit all the pieces together for a certain aspect of a large project we’re working here at ibrow towers. This particular problem was a three parter:

1. Users can FTP into a server into their own directory.
2. These users should be created automatically (i.e. sign up on site, get details, ftp) and have the same login credentials as the rest of the site
3. Uploads to the FTP server should be monitored and each file processed

To solve this three part problem, I utilised the following:

• VSFTPD FTP Server using MySQL as the credentials database
• incron as the directory monitoring
• bash as the glue

My server is running Debian, and I found the on Falko Timme tutorial for VSFTPD and MySQL at How To Forge incredibly easy to follow and it worked pretty much “out of the box”. It did take a bit of tweaking, but I was able to use my existing data structure to be used for the FTP login credentials.

The next task was directory monitoring. After some searching around I found incron. On a Debian system installation was a breeze:

$ sudo apt-get install incron

Now, for my VSFTP user I had to create an incrontab. First I had to add the user into the incron.conf file:

$ sudo nano /etc/incron.allow

This was blank, so I just added the line:

vsftpd

No to test this was working I created a small bash script that esentially appends to a text file. I created this in /home/vsftpd/bin/incron.sh

!/bin/bash
echo "start: $1 || $2" >> /home/vsftpd/bin/log.txt

The $1 and $2 variable are to store command line arguments which I’ll pass via the incrontab. Make this executable and quickly test this is working:

$ chmod 0755 /home/vsftpd/bin/incron.sh
$ /home/vsftpd/bin/incron.sh test hello
$ cat /home/vsftpd/bin/log.txt
start: test || hello

The test script is all working so now we need to call it whenever a file is uploaded. You need to edit the incrontab passing it the directory to monitor, which actions to look out for and then what script to call, passing any arguments.

$ incrontab -e

You’ll be taken to an editor where you should enter something like:

/home/vsftpd/cam1/ IN_CLOSE_WRITE /home/vsftpd/bin/incron.sh 123 $@$#

The IN_CLOSE_WRITE basically means, “once finished uploading”. “123″ is the user id, as I didn’t want the directory name to reflect the user id. Finally the $@$# is translated into the full path of the directory (as typed by you, so keep an eye on trailing slashes) and the file name that was caught by the incron, e.g: /home/vsftpd/cam1/my-file.txt

Now simply test this by FTPing and uploading something to the user’s directory. It’s always fun to do:

$ tail -f /home/vsftpd/bin/log.txt

to watch the log being updated in real time. Now that’s working you can change the incron.sh script to do anything you want!

The final thing to do is to automate the creation of the users’ FTP directories. When adding the directories we also want to ensure that they are correctly monitored. To solve this I wrote a small bash script that is saved on the FTP server, /home/vsftpd/bin/add-user.sh:

#!/bin/bash
 
# user id = $1
# user directory = $2
 
# Create the directory
mkdir /home/vsftpd/$2
 
# Add monitoring
incrontab -l > /tmp/$1.in
echo "/home/vsftpd/$2/ IN_CLOSE_WRITE /home/vsftpd/bin/incron.sh $1 \$@\$#" >> /tmp/$1.in
incrontab /tmp/$1.in
rm /tmp/$1.in

The important part of this is that we keep monitoring intact. And this is one of the reasons why I love Linux so much. By using incrontab -l to send the output to a tmp file, then echoing the new incrontab line to append that tmp file, then finally calling incrontab again, this time passing the tmp file we have just added a new directory to monitor, whilst keeping all the existing ones! Simple, elegant and it just works. One thing to not here is to make sure you escape the $@ and $# variables in the echo.

Make this executable:

$ chmod 0755 /home/vsftpd/bin/add-user.sh

Test this on the server:

$ /home/vsftpd/bin/add-user.sh 456 testdir

and you should see that the testdir has been created and monitored, associating with the user id 456. This script should be invoked during the user creation phase in your web app.

That’s it!

Through using bash, VSFTPD with MySQL credentials and the incrontab program I can now automatically create a new user, keeping it linked in with my website database, create the user’s FTP directory and monitor it for any uploads.

Using some faily simple tools together (here ftp, bash and incron) you can create some very powerful solutions.

We had a look around and we found a potential solution on this blog post.

We played around with this for a while but found that, whilst it was a good solution, it wasn’t quite suitable for our needs. What we needed was a solution which allowed us to have any number of columns and for each column to contain completely different content. The solution in the post demanded that each column start with the same HTML tag (H2 in the example). We decided to rewrite the function described above, based on the same principals, but updated and improved so it would fit our needs.

To see what the end result is, you can see a demo page.

The first thing the new function had to do was to split the content into the different columns using the more tag. In our tests, we found that Wordpress replaced the more tag with a span, but only in the first instance, all the rest were kept as a comment tag. The regular expression we used had to take this into account.

// the first "more" is converted to a span with ID
$columns = preg_split('/(<span id="more-\d+"><\/span>)|(<!--more-->)<\/p>/', $content);

This regular expression is not bullet proof, but it does the job for us. Specifically, if you are using a plugin like “Sociable” or something that appends stuff to the end of the content then this stuff will end up in the third column and not nicely across the bottom of the page. Also, it hasn’t been tested when adding images. These two issues weren’t going to be a problem for us, so the regular expression above is perfectly adequate for our needs.

Next we need to loop through each column, removing any stray <p> tags that may have been orphaned by the regular expression and putting the content into separate divs.

$col_count = count($columns);
for($i=0; $i<$col_count; $i++) {
 
	// check to see if there is a final, if not add it
	if(!preg_match('/<\/p>\s?$/', $columns[$i]) )  {
		$columns[$i] .= '</p>';
	}
	// check to see if there is an appending, if there is, remove
	$columns[$i] = preg_replace('/^\s?<\/p>/', '', $columns[$i]);
	// now add the div wrapper
	$columns[$i] = '<div class="dynamic-col-'.($i+1).'">'.$columns[$i].'</div>';
}

Finally we can join the columns back together to produce the final content.

$content = join($columns, "\n").'<div class="clear"></div>';

Notice that we have added a clearing div here. This is basically so you can clear the floats with CSS so any content displayed below the page content will be correctly positioned.

What if there isn’t a more tag? We will only have one column. As such there is no need to modify the content, so the code above should go into an if statement

if($col_count > 1) {
	...
}

The last job to do in this function is to clear out any blank <p> tags caused by the regular expression and return the content

// remove any left over empty tags
$content = str_replace('<p></p>', '', $content);
return $content;

This would normally all be contained in a function (we called my_multi_col_v2) that would be called as a filter function, however, we found that this was causing problems with the Wordpress excerpts, so instead we are overriding the default content display function in the page.php file.
In your page.php file, replace the line that calls the the_content() function

//the_content('Read the rest of this entry »');

Now we collect the content into a variable, then pass this variable to the new function, outputting the result. The function that gets the content instead of directly outputting it is get_the_content():

$content = get_the_content('',FALSE,''); //arguments remove 'more' text
echo my_multi_col_v2($content);

As we are using get_the_content() the default filtering that is normally done on the content is not being run. So at the top of our new function, we must manually run these

// run through a couple of essential tasks to prepare the content
$content = apply_filters('the_content', $content);
$content = str_replace(']]>', ']]>', $content);

This also caused a problem with line breaks when only displaying one column, so we needed to include an else statement that ran wpautop()

else {
	// this page does not have dynamic columns
	$content = wpautop($content);
}

So the final function looks like this:

function my_multi_col_v2($content){
	// run through a couple of essential tasks to prepare the content
	$content = apply_filters('the_content', $content);
	$content = str_replace(']]>', ']]>', $content);
 
	// the first "more" is converted to a span with ID
	$columns = preg_split('/(<span id="more-\d+"><\/span>)|(<!--more-->)<\/p>/', $content);
	$col_count = count($columns);
 
	if($col_count > 1) {
		for($i=0; $i<$col_count; $i++) {
			// check to see if there is a final </p>, if not add it
			if(!preg_match('/<\/p>\s?$/', $columns[$i]) )  {
				$columns[$i] .= '</p>';
			}
			// check to see if there is an appending </p>, if there is, remove
			$columns[$i] = preg_replace('/^\s?<\/p>/', '', $columns[$i]);
			// now add the div wrapper
			$columns[$i] = '<div class="dynamic-col-'.($i+1).'">'.$columns[$i].'</div>';
		}
		$content = join($columns, "\n").'<div class="clear"></div>';
	}
	else {
		// this page does not have dynamic columns
		$content = wpautop($content);
	}
	// remove any left over empty <p> tags
	$content = str_replace('<p></p>', '', $content);
	return $content;
}

The next thing to do is to update your CSS so it lays out the columns correctly. In the demo I have used three columns, and the CSS for it looks like this:

/* dynamic columns */
div.dynamic-col-1 { float: left; width: 38%; padding-right: 2%;}
div.dynamic-col-2 { float: left; width: 38%;padding-right: 2%;}
div.dynamic-col-3 { float: left; width: 20%;}
div.clear { clear: both; }

And that’s pretty much it. Have a look at the demo, below is a screenshot of the Wordpress editor screen so you can see that it really is controlled by the user, you should see the two more tags that are used to split the content into the three columns.

Wordpress multiple content columns, editor input

Please feel free to take this, improve it, update it, completely rewrite it. If you do please can you drop me a comment and let me know. And a big thanks to Kriesi for his initial work and for providing inspiration for this blog post. ]]> http://www.robsearles.com/2009/07/05/wordpress-multiple-content-columns/feed/ 30 http://www.robsearles.com/2008/12/14/timesheet-ng-experimental-web-installer/ http://www.robsearles.com/2008/12/14/timesheet-ng-experimental-web-installer/#comments Sun, 14 Dec 2008 01:09:25 +0000 Rob Searles http://www.robsearles.co.uk/?p=43 I’ve just committed a new very basic web installer for Timesheet Next Gen which is the Timesheet and job tracking open source web app that I’m trying to contribute to when I have a spare moment.

Only in the SVN repository at the moment, but if you have a chance you can get check it out anonymously from SourceForge using your favourite SVN app here:

https://tsheetx.svn.sourceforge.net/svnroot/tsheetx/branches/exp_installer

More details in the news page

Warning – in no way is this stable yet and should not be used for mission critical situations!

For this I initially set up .htaccess password protection – quick and simple.

However, we found out that this prevented the Wordpress iPhone App from login in and doing it’s stuff. So we had to look for another solution.

After doing some Googling I found a post all about password protecting wordpress on the Cre8d Design blog. This pointed me to the “Registered Only” plugin. Whilst it is quite old (4 years since last commit) it should have been just what I was looking for, so I downloaded it, installed and activated (taking care to follow the readme and remove the RSS feeds)

When testing it out it displayed the login box on first visit to the site – prefect. However, I logged in, but it still showed the login box. I assumed I typed in the wrong password, so I tried again. Same result.

Argh, a bug!

Probably because it was meant for a much older version of Wordpress (this blog was using 2.6.3 – now upgraded to2.7)

There was only one thing for it, I had to view the source! Which turned out to be relatively simple:

function carthik_bouncer() {
    if (substr($_SERVER['SCRIPT_NAME'], -12) != "wp-login.php") {
        auth_redirect();
    }
}
add_action('init', 'carthik_bouncer');

The problem was clearly the auth_redirect() function. After some searching, I found this thread in the Wordpress Support forums, after which I dutifully modified the code to this:

function carthik_bouncer() {
    if (substr($_SERVER['SCRIPT_NAME'], -12) != "wp-login.php") {
	    if (!is_user_logged_in()) { auth_redirect(); }
    }
}
 
add_action('init', 'carthik_bouncer');

Success! It works prefectly.

If you need to know, here is a patch:

--- registered-only-old.php	2008-12-12 14:00:09.000000000 +0100
+++ registered-only-new.php	2008-12-12 14:01:21.000000000 +0100
@@ -26,7 +26,7 @@
 
 function carthik_bouncer() {
     if (substr($_SERVER['SCRIPT_NAME'], -12) != "wp-login.php") {
-        auth_redirect();
+	    if (!is_user_logged_in()) { auth_redirect(); }
     }
 }