My new business cards arrived today and about half of them look like this. I’m going to have to dedicate myself to becoming a true master of Puppet to be worthy of these!

That and buy my manager a beer or five.

Born to Beta
Who knew? Our beta users are 96% male. Less than a quarter of you were alive when the US put a man on the moon. And most use the internet to communicate. So…why not communicate a bit and help us get newbies testing Firefox?! We need feedback from women, non-techies and people who spend less time online, like baristas, elephant trainers, teachers, surfers or acupuncturists… Tell your friends!

Beta users being 96% male is quite interesting, really. It’s not that women don’t use computers, I know that well enough – but obviously they’re not downloading Firefox 4. I have no reason to disbelieve or take issue with these statistics – Firefox would know, after all.

I do however object pretty strongly to Firefox equating women as a group with ‘newbies’ and ‘non-techies’. Thank you Firefox for continuing to uphold negative and damaging gender stereotypes in 2010 when this stuff just shouldn’t happen anymore. Attitudes like this are a real and present barrier to women being involved in technology. If you hear enough times that you don’t belong, it’s pretty understandable that eventually, you might start believing it. In that way, a little throwaway comment like this is more important than it might seem on the surface. It becomes one of many, and those many constantly erode self-esteem.

Besides, it’s pretty clear to me why women aren’t downloading Firefox 4. It’s because Google Chrome comes in pink. Have Firefox tried marketing to women’s intrinsic pinkness?

I think not.

WARNING: The final paragraphs of this post contain sarcasm.

One of the first little things I missed from Ubuntu was the ability to get a coloured bash prompt by uncommenting the included colour PS1 variable from the default bashrc. I also like to have different coloured terminal prompts for both my unprivileged user account and root, to give me an extra little visual reminder that I should be quite careful with rm -rf about now.

Since I was going to need to craft a new PS1 string anyway I went slightly overboard and ended up creating a two-line prompt that was reminiscent of one of my favourite zsh prompts, elite2.

The Bash Prompt HOWTO has some excellent resources for creating custom bash prompts. By building a string out of the escape sequences and colour codes listed in the URLs below, it’s quite simple to create very complex looking prompts.

http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x329.html
http://tldp.org/HOWTO/Bash-Prompt-HOWTO/bash-prompt-escape-sequences.html

PS1="\[\e[0;34m\][\[\e[0;33m\]\u\[\e[0;34m\]@\[\e[0;33m\]\h\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;33m\]\t\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;33m\]\j \s\[\e[0;34m\]] \n[\[\e[0;33m\]\w\[\e[0;34m\]]\[\e[0;36m\]\$:>\[\e[0m\] "

The finished product looks a little like line noise, but isn’t too hard to break down into its component parts.

\[\e[0;33m\] - Yellow until another color or reset
\[\e[0;34m\] - Blue until another color or reset
\[\e[0;36m\] - Cyan until another color or reset
\u - Username of current user
\h - Short hostname of current system
\t - Current system time in 24 hour mode
\j - Number of jobs the shell is currently managing
\s - Current shell ($0)
\n - Newline
\w - Current working directory
\$ - Print $ if unprivileged user, # if root.
\[\e[0m\] - Text Reset

In amongst the escape codes are the literal characters “[", "]“, “@”, “-” “:” and “>”, building the static structure of the prompt. To build this prompt or a similar one, it’s easier to start crafting the prompt you want without colour.

PS1="[\u@\h] - [\t] - [\j \s]\n[\w]\$:> "

Test your prompt, and once you’re satisfied with it, start adding the colour codes between elements to create the colour effects you want. Remember that a colour code will continue colouring text until a new colour code or a reset – if you forget to include a text reset at the end, you will find all your typed commands have inherited the last colour specified in your prompt. Once you’re satisfied, add the PS1 line to your ~/.bashrc, removing or commenting out any PS1 lines that your distribution may have included by default.

Now that I’ve created my user prompt, I’m going to create a second one for the root account. It’s going to look the same as the previous one, with the exception that all of the text coloured yellow in my prompt is going to become red, to remind me that I’m currently running with root privileges.

if [ $UID -eq "0" ]; then

    PS1="\[\e[0;34m\][\[\e[0;31m\]\u\[\e[0;34m\]@\[\e[0;31m\]\h\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;31m\]\t\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;31m\]\j \s\[\e[0;34m\]] \n[\[\e[0;31m\]\w\[\e[0;34m\]]\[\e[0;36m\]\$:>\[\e[0m\] "

    else

    PS1="\[\e[0;34m\][\[\e[0;33m\]\u\[\e[0;34m\]@\[\e[0;33m\]\h\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;33m\]\t\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;33m\]\j \s\[\e[0;34m\]] \n[\[\e[0;33m\]\w\[\e[0;34m\]]\[\e[0;36m\]\$:>\[\e[0m\] "

fi

Inserting this code into ~/.bashrc will check whether the uid I’m running under is equal to 0 – the root user. If so, it will set the first PS1 as my prompt, which uses red text. If I am any UID other than 0, it will set the second, which uses yellow.

These should always work for sudo, as sudo does not source root’s environment. Traditionally, su is intended to keep the user’s environment, while su - will source root’s environment. This does seem to depend on the distribution however, so using su may or may not source your own ~/.bashrc. If you find yourself getting the old system prompt when you use su you can insert just your intended root prompt, for example:

PS1="\[\e[0;34m\][\[\e[0;31m\]\u\[\e[0;34m\]@\[\e[0;31m\]\h\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;31m\]\t\[\e[0;34m\]] \[\e[0;35m\]- \[\e[0;34m\][\[\e[0;31m\]\j \s\[\e[0;34m\]] \n[\[\e[0;31m\]\w\[\e[0;34m\]]\[\e[0;36m\]\$:>\[\e[0m\] "

Into the root user’s ~/.bashrc to ensure that if root’s settings are sourced, you will still get your custom prompt.

Some may have noticed that the colour codes I’m using look different to those in quite a few tutorials. The reason for that is that I’m escaping the non printing characters using \[ and \]. If I hadn’t done this, Bash would have trouble calculating the length of my prompt and a two-line prompt would cause my text to overlap strangely instead of wrapping. Using colour codes like the ones below ensure that your text will wrap around to the next line correctly. To get bold or underlined text, replace the first ’0′ in the code with ’1′ or ’2′ respectively.

\[\e[0;30m\] - Black
\[\e[0;31m\] - Red
\[\e[0;32m\] - Green
\[\e[0;33m\] - Yellow
\[\e[0;34m\] - Blue
\[\e[0;35m\] - Purple
\[\e[0;36m\] - Cyan
\[\e[0;37m\] - White
\[\e[0m\] - Text Reset

It seems as though there are as many Linux distributions as there are letters in the alphabet with which to name them. Certainly, there is a flavor to satisfy almost any palate. It wasn’t always this way, however. How did it happen? Why hasn’t the Linux world just standardized on a single distribution?

The beginning of the Linux distribution really started with Richard Stallman and his fledgling Free Software Foundation in the early 1980s. The GNU operating system was being developed, intending to re-implement a UNIX-like operating system as free software. Although many GNU tools enjoyed wide use, the project suffered various setbacks and delays in its hunt for a kernel. There was a lack of cooperation from some at Berkeley with using the BSD kernel, and there were licensing issues with Mach (Carnegie-Mellon University’s microkernel). Before these issues were resolved and the GNU Project was able to make headway building its own kernel, Hurd (another free kernel) became available for use. Then in 1991, the following message appeared on a Usenet newsgroup:

Hello everybody out there using minix-

I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu) for 386(486) AT clones. This has been brewing since april, and is starting to get ready. I’d like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things).

I’ve currently ported bash(1.08) and gcc(1.40), and things seem to work. This implies that I’ll get something practical within a few months, and I’d like to know what features most people would want. Any suggestions are welcome, but I won’t promise I’ll implement them :-)

Linus

(PS. Yes – it’s free of any minix code, and it has a multi-threaded fs. It is NOT protable [sic] (uses 386 task switching etc), and it probably never will support anything other than AT-harddisks, as that’s all I have :-(

Linux provided a stopgap measure for the free kernel GNU needed to be a complete operating system. Because Linux was no more and no less than a kernel, it similarly needed tools like those provided by GNU and other projects to be usable by anyone other than a developer. Early enthusiasts put together bundles of software running on the Linux kernel, creating the first distributions. These early distributions were mostly created by universities for internal use, some releasing their handiwork to the wider community.

With Linux 0.12, Linus announced his intention to license the kernel under the GNU GPL (General Public License). Achieved by the release of Linux 0.99, this removed the prior restriction on commercial distribution, paving the way for commercially backed distributions that were soon to come along.

One of those was Soft Landing Systems’ SLS Linux, one of the first widely used distributions. It was installable by floppy disk and included such cutting-edge features as TCP-IP networking support and the X Window System. SLS enjoyed popularity for the time, but it came under criticism for being buggy and unstable. When Soft Landing Systems announced it was going to change the default binary format from a.out to ELF, it met with a very negative response from the user base.

Among those upset by Soft Landing Systems’ decision was Patrick Volkerding, who then created a modified version of SLS he named Slackware. The first release was July 16, 1993, and Slackware holds the honor of being the oldest currently maintained Linux distribution—by a few months.

Ian Murdock also became quite frustrated with the flaws he perceived in SLS, and he announced on the newsgroup comp.os.linux.development on August 17, 1993:

This is just to announce the imminent completion of a brand-new Linux release, which I’m calling the Debian Linux Release. This is a release that I have put together basically from scratch; in other words, I didn’t simply make some changes to SLS and call it a new release. I was inspired to put together this release after running SLS and generally being dissatisfied with much of it, and after much altering of SLS I decided that it would be easier to start from scratch.

In the same year, Ian Murdock released the Debian Manifesto, detailing his vision for a free and open distribution that would be developed and maintained communally. He saw such a distribution as the way to avoid stagnation, crucial to Linux’s success in the commercial market. The Free Software Foundation supported these efforts by funding Debian development for a year.

Both Debian and Slackware were born of the dissatisfaction of not just the problems with SLS but the closed nature of the distribution preventing any improvements being submitted by the user base. Ian Murdock’s solution of having a distribution where many hands made light work of high standards persists today, although Debian’s development process has come under criticism for its long release cycles.

Although Murdock built his solution on community involvement, Volkerding’s response was almost the polar opposite. The Slackware team did grow to multiple developers; however, as late as 2000, all changes still were being signed off personally by Volkerding as the project’s “czar”. This, he was recorded to have said, ensured that there was “…a high level of quality and consistency”

Red Hat Linux was another of the successful early distributions. Marc Ewing was developing software for the UNIX platform but turned to Linux as a more affordable option than a UNIX workstation. He found after a time that rather than work on his main project, he spent the majority of his time fixing issues with Linux. Marc eventually decided to put his original project aside and “…work on putting together a better Linux distribution” as a business venture.

His first version took about a year and a half, and released in 1994. Bob Young purchased most of the produced copies of the distribution for ACC Corporation, a mail-order business that sold Linux- and UNIX-related products, including distribution media. Not long after that, in 1995, Young bought Ewing’s business and merged it with ACC to become Red Hat Software. That year, Red Hat 2.0 was released, including the then-new RPM package management system. Four years later, Red Hat bought and merged with Cygnus, becoming the largest open-source company in the world at that time.

SuSE, standing for Software und System-Entwicklung in German (Software and Systems Development), originally started as a software development and UNIX consultancy company, consisting of its four founders Roland Dyroff, Thomas Fehr, Burchard Steinbild and Hubert Mantel. Their original business plan did not succeed, so SuSE moved on to distributing Linux. To start with, SuSE provided software packages and services based on SLS. Once Patrick Volkerding had created Slackware, SuSE began translating it into German.

For some time, SuSE continued to translate and distribute Slackware, but for much the same reasons that Patrick Volkerding and Ian Murdock became frustrated with SLS, SuSE grew dissatisfied with Slackware. Slackware’s closed development prevented SuSE from having its improvements and changes accepted. Disappointed by bugs it was unable to fix, SuSE decided to create its own Linux distribution.

The SuSE team identified a need for an easy-to-use installation and configuration tool and started work on YaST, the core of modern SuSE Linux. Over time, SuSE incorporated many features of Red Hat Linux, including the RPM packaging system and the Red Hat-style rc system.

Of course, both Red Hat and SuSE exist in somewhat different forms today. Red Hat eventually stopped supporting the free version of its operating system to focus on Red Hat Enterprise Linux, with the Fedora Project stepping in to maintain the community-focused distribution. SuSE Linux went through a similar change not long after being acquired by Novell, with OpenSUSE rising as a new free and open flavor. Slackware and Debian have navigated the years more or less intact, with Ian Murdock’s vision of Linux’s commercial success realized not in Debian itself but in the one who was yet to come—Ubuntu.

These are just the earliest distributions whose impact still clearly can be seen in the Linux world, with all of them featured on DistroWatch’s top ten distributions list (albeit with the metamorphosized forms Fedora and OpenSUSE). Many others were not as successful but also played a part in shaping the early face of Linux—bonus points to any readers who have been Linux users long enough to remember MCC or Yggdrasil.

All four of the successful distributions had the common trait of providing a Linux distribution that was improved and easier to use, and all four of the distros discussed here were frustrated with their efforts at trying to contribute to the projects that had come before them. Ultimately, the story behind our myriad Linux distributions is like that of Linux itself: each was started by the most pragmatic kind of dreamer who could visualize a better way and had the talent and drive to make that vision real.

Resources:

comp.os.minix: groups.google.com/group/comp.os.minix/msg/b813d52cbc5a044b?pli=1
comp.os.linux.development: groups.google.com/group/comp.os.linux.development/msg/a32d4e2ef3bcdcc6
Replies from Slackware Founder Patrick Volkerding: http://slashdot.org/interviews/00/03/17/1120205.shtml
Linux at the bat: http://www.salon.com/tech/view/1999/10/04/marc_ewing
Release Note for Linux v0.12: www.kernel.org/pub/linux/kernel/Historic/old-versions/RELNOTES-0.12
The Debian Manifesto: www.debian.org/doc/manuals/project-history/ap-manifesto.en.html
Red Hat History: www.redhat.com/about/companyprofile/history
DistroWatch: distrowatch.com/dwres.php?resource=major
Linux Timeline: www.linux.org/info/linux_timeline.html

I have been very surprised by how excellent the applications are on the android platform. They easily match the quality of the applications available for the iPhone, and I have managed to find an application to fill every need without paying a cent. There seems to be a much wider range of high-quality free apps available in the market – at least, within my areas of interest. Some of my favourites include:

Aldiko

I’m a voracious reader who was won over to the concept of ebooks many years ago. Aldiko is my favourite application so far on Android. It supports both importing books from SDcard and downloading them from a variety of bookstores within the app, both free and paid. I have found the public domain classics downloadable for free through the app to be beautifully formatted. Purchased epub files from OReilly.com and Baen import without a hitch. The Nexus One’s large, high DPI display makes for an excellent reading experience.

KeepassDroid

KeepassDroid is an implementation of a Keepass compatible password safe for android. Combined with Dropbox, I use it to keep my password database on-hand wherever I am. It registers itself on the phone as a handler for kdb files, and so can open them directly from the Dropbox application. I prefer to use Dropbox to download the database to the SDCard so that I can access my passwords offline. KeepassDroid allows for adding, removing, and editing entries as well as viewing saved passwords. While viewing an entry, KeepassDroid inserts username and password copy actions into the notification area. This allows for quick and easy pasting of authentication data into application configuration dialogues or web forms.

WordPress

I don’t blog anywhere near as much as I’d like to, but more damningly I’m dreadfully lax about moderating comments on my various blogs. Akismet takes most of the pain out of dealing with spam, but nothing works quite as well as logging in to check the comments queue and manually fixing the ones it gets wrong. The WordPress application for android should change all that.

It supports both WordPress.org blogs, and instances of WordPress managed elsewhere. The application provides a simple interface for managing comments, posts, and pages. Writing a post of this length on the touch keyboard sounds like an exercise in frustration, but the application provides an excellent way to moderate and reply to comments on the move.

I traded my Nokia E90 for an iPhone because of the dearth of high-quality applications on Symbian. While the iPhone has a wide variety of good software, I became more and more irritated with the limitations of the platform. Android really seems to combine the best parts of both platforms, allowing me to access my data without needing to use proprietary software; and still providing a polished and feature rich user experience.

Developer A notices. He tells Person A that if she can write her solution up as a FAQ entry, like the examples he shows her, he will see that it’s posted on the FAQ so that everyone can share her solution. She does so, and finds other problems she can fix. They are very small – but Developer A keeps taking the time to assist her. Eventually she starts contributing larger chunks of content. Developer A arranges for her to get commit access and as the years go past she writes tens of thousands of words of documentation and becomes a strong advocate of the project, writing articles that get published all over the web about just how awesomesauce this project is.

More recently, Person A notices someone in another project have a problem she has also had. Their documentation is excellently written, but there are some knowledge gaps and some parts are hard to find, even if you search willingly and carefully. She chimes in with Person B, pointing out she’s had some of the same problems with the documentation. She can’t point to an exact solution as this situation is far more broad, but she points Person B to some documentation she had written of her own that she thought might be of help to him.

Developer A notices. He informs her that she is wrong, and the documentation she is looking for does in fact exist. He links her to this documentation to prove it. She clarifies that whether the documentation existed or not, a genuine search did not find it for her and this perhaps shows there’s a problem of visibility. This being IRC, private messages telling her that she is an idiot and should stop asking to be spoonfed start rolling in. No-one on the internet can resist an opportunity to argue.

Unfortunately, the situation quickly gets out of hand from there. Developer A, joined by Developer B, have a full-blown argument with Person A who is becoming less and less coherent as she tries to explain her position and ignore the private message windows lighting up with insults. Developer A and B are convinced she is insisting that the documentation they showed her does not exist. Person A cannot understand how this can be read from her saying the documentation is hard to find. Developer B seems like he might have actually been a helpful person to her if she had spoken to him first, as he at least is listening to what she has to say rather than rebutting arguments she has not made. Unfortunately it was Developer A who answered first and Developer B has come into the situation assuming that Person A is trying to be difficult, rather than realising Developer A has managed this situation poorly and contributed strongly to the escalation. Person A, also being a nerd on the internet, gets sidetracked into arguing who is right instead of actually arguing her point.

Once she realises that the situation cannot be salvaged, Person A flees vowing not only that she will not contribute to this project, but regretting that she must still use their product. Developer A and B are gleeful, thinking they have proved that this person was not going to do any work for them anyway.

Person A is still the same person, with the same skills and the same willingness to help out with documentation as she loves to write. She knows their product well, and would be very capable of starting to fix the documentation knowledge gap. How did it all go so wrong?

Obviously, Person A is me. I managed to get into such a dreadful argument on a project IRC channel earlier today that I was accused of trolling. The accusers hadn’t been involved from the beginning and had only seen me stubbornly repeating the same rebuttal to someone who was just as stubbornly repeating back the same fallacy they’d attributed as being said by me. From that perspective, I can completely understand where they are coming from – but I also firmly believe that this community created the situation in which someone who usually communicates well and has a proven history of contributing to open source projects and a willingness to help with theirs is turned into an angry and somewhat accidental troll.

In the first scenario, a representative of the project notices my interest in the documentation and encourages me to help out and fix it. He lowers the barrier by showing me exactly how to start. If I write something that is like this specific example here, I can email it to him and he will take care of the rest. These are simple steps a new person can easily follow. In order to continue contributing, I must eventually learn SVN, Docbook, and how to create diffs of XML documents. At every stage, the Developer helps and his work pays off when I become a fully autonomous writing machine, no longer needing his help and able to in turn help others. His initial investment in time however was very slight – a short discussion on IRC, a URL, and an offer to mark up and commit my documentation if I did in fact write anything he could use. No more than five minutes of his time would have been wasted if I had turned out to be trolling and as it turned out his risk was well spent and the gain to the project was measurable.

In the second scenario, the Developers think they are being helpful but they’re starting from a much more argumentative position. Their refusal to accept that there is a problem in the first place that I would be willing to help with wastes everyone’s time. They believe they are playing a trump card by insisting that I go to the wiki and just ‘click edit then!’ but this doesn’t wash – I know that it should be more complicated than that to edit a project’s finalised documentation! – and by the time they suggest this action everyone is angry and unwilling to cooperate. As a last ditch effort I ask for information online on how to contribute documentation – a style guide, a glossary, anything that would lower the barrier – and is told it does not exist. Developer B admits that perhaps this is a gap that should be filled and I could help there – but by now no-one involved in the conversation has any interest in helping anyone.

Many open source projects become their own worst enemies in situations like this. Attracting new contributers is necessary for a project to survive, as long as those contributers are genuine and have skills the project can use. Unfortunately, to someone trying to break into a community it’s not obvious at times where to go or who to talk to. IRC and mailing lists become the first point of contact and those project members who are most aggressive and argumentative are the ones who respond.No matter how knowledgeable these members of the community are, aggression is the antithesis to good communication. Someone being WRONG on the internet turns very quickly into a situation where being right becomes more important than actually trying to understand what this person is saying.

The saddest thing about this whole situation is that so often, the fact that the outsider was driven away is seen as the project members winning the argument. They believe they’ve proven that they are right, and that they’ve succeeded – when really, by any measure of benefit to the project, they’ve quite clearly failed.

After three years of being a faithful iPhone fan, I’ve switched to Android.

I’ve just finally had enough. No matter how polished the user experience is, or how great the hardware, I am sick of being frustrated by iPhone’s petty limitations. When almost every application I have installed includes a built-in web server to get data back out of it again, something has gone pretty wrong.

Unlike many, iTunes wasn’t the breaking point for me. I really enjoy iTunes as a distribution platform, and I’m going to continue using it as a way of purchasing music that’s DRM free. I did however object to iTunes and my phone being so strongly shackled. It was very frustrating being at work, away from my main iTunes library, and wanting to get some data transferred to my phone. Well, I could use very expensive 3G internet … or just wait until I get home, I guess.

It made the experience feel less portable, less mobile. It came to remind me of working in locked down environments – the frustrating juggling act of trying to move data around with arbitrary restrictions. I need to get this file onto this server – but when I’m not allowed to plug my laptop into a network that it shares, how can I do this while breaking the minimum number of rules?

It came to a head when I realised that I’d used my hacked HTC Hero more often in the previous week than I had my iPhone, as whenever I wanted to load something onto a portable device it was the path of least resistance. Plug it into my computer over USB, load what I wanted onto the SD card, and now I can not only take the data with me but transfer it just as easily to another machine when I get there.

I decided to replace my iPhone with a Nexus One, and so far I love it to pieces. The screen is just magnificent and the performance is amazing. I’m told that Android 2.2 will be faster, but I’m having trouble imagining how that’s possible. Does it read my mind and open the applications before I tap the icon?

I was concerned that I’d miss the polish of the iPhone but that hasn’t turned out to be the case at all. The Nexus One has far fewer rough edges than I’d feared, and has a certain flair to it that I’m already learning to love.

Puppet is an automation framework for UNIX and UNIX-like operating systems. It allows sysadmins to automate common tasks in a centralised, efficient, and scalable way.

I’ve recently started looking into Puppet, drawing on my experience managing a large and convoluted Cfengine environment. While Cfengine is an excellent tool and certainly the best choice at the time, Puppet’s more declarative syntax makes for easier to maintain code. While in the Puppet tutorial at LCA this year, I was able to read and understand all of the example recipes without having had any real prior exposure to Puppet or Ruby.

Learning Puppet basics has required a shift in my thinking. I would waste a lot of time over a recipe trying to make Puppet ‘do’ something. Then my perspective would shift with an almost audible thunk and I’d realise where I’d gone wrong. Instead of micromanaging the mechanics of ‘doing’ things, Puppet requires you to define a state you want to acheive. It’s a suble difference, but an important one. I spent a fruitless hour trying to make Puppet create a directory before realising that I needed to tell puppet to maintain the directory.

As an example, here’s a simple class to ship out an authorized_keys file for the root user.

class ssh-keys {

	file { "/root/.ssh":
		ensure => "directory",
		owner => "root",
		group => "root",
		mode => "600",

	}

	file { "root/.ssh/authorized_keys":
		owner => "root",
		group => "root",
		mode => "600",
		source => "puppet:///ssh-keys/authorized_keys",

	}
}

This class ensures that the directory /root/.ssh exists, and has the correct permissions. It then copies out an authorized_keys file from the puppet server, stored in the ssh-keys class definition, and again ensures this file has the correct permissions.

My only real complaint about Puppet so far is that the documentation can occasionally be a little hard to follow. There are plenty of example recipes on the ‘net, but many are extremely complicated and it can be hard to find more simple examples to learn from and build apon. One area in which this was especially true was templating. I had to do quite a bit of digging around before confirming that all facter variables were accessible in templates.

Here as a simple example of using facter variables in templating is a snippet of a class for managing a resolv.conf file.

file { "/etc/resolv.conf":
	owner => "root",
	group => "root",
	mode => "644",
	content => template("resolv.erb")
}

This file management block ensures that the file /etc/resolv.conf exists, has the correct permissions, and has the content set out in the template ‘resolv.erb’.

resolv.erb:

search <%= domain %>
nameserver xxx.xxx.x.x
nameserver xxx.xxx.x.x

Where ‘xxx.xxx.x.x’ are valid nameserver addresses.

This simple template takes the server’s domain from facter, and inserts it in place of the variable “<%= domain %>”. Another very simple template could include:

hosts.erb:

127.0.0.1 localhost.localdmain localhost
<%= ipaddress %>	<%= fqdn %> <%= hostname %>

Here the template ensures the correct localhost entry, and the ‘real’ ip address and hostname of the server are listed.

Obviously there is far more that can be done with puppet than these simple beginner’s examples here. For more information, and for information on how to set up your puppet environment, see Puppetlabs.com

Day four of the conference opened with a keynote entitiled “Hackers at the End of the World” by Glyn Moody. Glyn explored the history of sharing in science and art as inspired by the open source movement, and contrasted this with the anti-sharing ‘my gain is your loss’ culture of the global financial community. Glyn postulated that the sharing and indeed sharing of sharing that characterises the FOSS community held a tantalising glimpse of a solution to the global financial and environmental crisis.

Jeremy Allison brought forward an extremely provocative look at Microsoft’s overtures to the open source community with “The Elephant in the Room – Microsoft and Free Software”. Jeremy took the audience through Microsoft’s duality in recent times in attempting to reconsile with the open source community at the same time working against them in the political and regulartory arena.

Jonathan Oxer delighted attendees with a talk on “Tux on the Moon”, showcasing the Lunar Numbat project and it’s efforts to partner with the Google Lunar X-Prize team White Label Space to “… put a Linux powered robotic Australian marsupial on the moon”.

The day was concluded by a Professional Delegates Networking Session at the Wellington Opera House. The final day of the conference will open with a short keynote by Nat Torkington and a series of lightning talks, with the conference Penguin dinner closing the evening activities.

The glorious weather that had punctuated the first two days of the conference held, heralding in the third day in a blaze of sunshine. The conference proper was introduced by a keynote by Benjamin Mako Hill on Antifeatures: Why your software works against you and why software freedom offers hope of a better future. Mako explored the concept of anti-features as deliberately included functionality or a lack of functionality that users hate so much they will pay to have them removed. Some classic examples included the gator spyware that was included with free version of p2p software on the windows platform – with a spyware-free version available for a fee.

Mako took the audience through why anti-features exist to further profits, and showed how in an environment dominated by free and open software they would be unable to survive.

Fowllowing the keynote session, Jonathan Corbet gave his traditional Kernel Report, covering major milestones in kernel development since last year’s conference, and addressing the challenges the kernel development team face in the year to time. Those of us with massively parallel-processing netbooks will be pleased to know the Linux kernel now scales to 4096 cpus.

Matthew Carretts talk on social Success in (and for) the Linux community covered many of the reasons that the Linux community can be a hostile and toxic place for new contributers to enter. He covered how aggressive and confrontational behaviour is rewarded and how as a community Linux will need to learn to welcome and retain new members.

As comic relief I caught Paul Fenwick’s engaging presentation on the World’s Worst Inventions. Covering such gems as cocaine cough-drop marketed to children and the recent children’s bead product that metabolised to GHB when ingested, Paul went through a few hundred years of misguided and downright dangerous inventions.

The fourth day of the conference will feature a keynote by Glyn Moody, provocatively titled ‘Hackers at the End of the World’, and also the Professional Delegates Networking session.