Christian thoughts in a tech world

From openvz to VMWare

2012-03-14T10:57:00.000+01:00

I was recently asked to convert an openvz container to a VMWare instance. I found a tutorial on a forum which helped but had to be adapted slightly.

Here is how I eventually managed to do the conversion:

On the openvz host, create an image (in my case, I need 20GB):
dd if=/dev/zero of=test.img bs=516096c count=40000
Create a partition table in the image:
fdisk test.img
Type: o n p 1 2048 w
Mount the image using the offset corresponding to the partition table (in our case, 2048*512=1048576):
losetup -o1048576 /dev/loop0 test.img mke2fs -b1024 /dev/loop0 tune2fs -j /dev/loop0 mount /dev/loop0 /mnt
Retrieve the UUID of the partition. Note it somewhere, you will need it several times:
blkid /dev/loop0
Copy the container files to the image. I used rsync to exclude some data that were too big. Make sure to use --numeric-ids to prevent bad mapping of UIDs:
rsync -av --exclude 'somedir' --numeric-ids /vz/root/1234/ /mnt
Install grub on the disk:
grub-install --root-directory /mnt /dev/loop0
Chroot into the mounted partition:
chroot /mnt
Install a kernel and grub (using apt for example):
apt-get install linux-image-foobar #adapt to your kernel version apt-get install grub-pc
Give a password to root:
passwd
Change inittab to add the ttys:
1:2345:respawn:/sbin/getty 38400 tty1 2:23:respawn:/sbin/getty 38400 tty2 3:23:respawn:/sbin/getty 38400 tty3 4:23:respawn:/sbin/getty 38400 tty4 5:23:respawn:/sbin/getty 38400 tty5 6:23:respawn:/sbin/getty 38400 tty6
Create an /etc/fstab file (change the UUID with yours):
proc /proc proc nodev,noexec,nosuid 0 0 UUID=7925e5b1-f2ad-4cdc-95f9-984d25378194 / ext4 errors=remount-ro 0 1
Umount the image and convert it to a vmdk image:
umount /mnt kvm-img convert -f raw test.img -O vmdk test.vmdk
Boot the machine on the virtual disk with VMWare or Virtualbox. You should get a grub prompt (adapt with your UUID). In grub2, you can use autocompletion for the Linux kernel and the initrd image:
grub> insmod ext2 grub> set root='(hd0,msdos1)' grub> linux /boot/vmlinuz-foobar root=UUID=7925e5b1-f2ad-4cdc-95f9-984d25378194 ro grub> initrd /boot/initrd-foobar grub> boot
Log in to the machine and run update-grub
Adapt your network settings

Announcing Augeas 0.10.0

2011-12-03T21:46:00.001+01:00

Augeas 0.10.0 has just been released, and it brings a good lot of changes with it.

Among them, the aug_to_xml method has been added. This is essentially an integration of the XML export function initially introduced in the Config::Augeas::Exporter Perl module. The port in C has seen some improvements in the XML schema, as well as in speed. There is not yet an aug_from_xml method, and it might take some time to come, as it brings up a lot of merging issues. This change introduces a dependency on libxml2.

Dominic Cleal has been working on the new aug_srun method, which he wishes for his Augeas module for Puppet. In order to achieve this, he introduced a way to set the context of XPath expressions in /augeas/context in order to use relative paths. This is a well-known feature for the users of the Augeas module for Puppet, and it is now available for all Augeas users.

A lot of lenses have been fixed and improved. As a matter of fact, when I wrote the Config::Augeas::Validator Perl module, the goal was initially to test our configuration files against the Augeas lenses. But after testing some 120.000 files, I've obviously found a few flaws in the lenses and had to fix them.

The package for Augeas 0.10.0 has entered Ubuntu Precise this afternoon. Versions for older releases are available on my Augeas PPA. Feedback is most welcome!

Unit testing your configuration files

2011-12-03T21:12:00.001+01:00

At work, we have a lot of different services running and we end up with hundreds of thousands of configuration files in our configuration repository (especially since we don't use templates - more on that in another upcoming post...).

In order to ensure the quality of these files (avoiding syntax errors and insecure configurations alike), we had the idea of writing a system to unit test the configuration files. Being involved in Augeas, I thought it would make a great parsing backend to write the tests.

This gave birth to what is currently a Perl module called Config::Augeas::Validator, which comes with a Perl script and an SVN wrapper (this is what we used, but wrappers for other VCS are welcome) to plug it to pre- and post-commit hooks.

The module relies on Augeas (and its lenses) to parse the configuration files. On top of that, you need to specify rules (which are essentially unit test scenarii), at least one for each type of file you wish to test. A minimal rule might look like this:


[DEFAULT]

lens=Fstab

pattern=.*/fstab

This rule will tell augeas-validator to test all files whose full path matches .*/fstab against the Fstab.lns Augeas lens. If the file contains syntax errors (that is, the lens fails to parse it), the program will report it and exit with a status of 1.

Here is another simple example adding two unit tests with warnings:


[DEFAULT]

lens=PHP

pattern=.*/(php\.ini|php[45]/conf\.d/.*\.ini)



[file_uploads]

name=file_uploads

explanation=file_uploads should be set to 'Off'

type=count

expr=$file//file_uploads[. != 'Off']

value=0

level=warning

tags=security



[expose_php]

name=expose_php

explanation=expose_php should be set to 'Off'

type=count

expr=$file//expose_php[. != 'Off']

value=0

level=warning

tags=security

This test checks for php.ini files. Not only does it fail with status 1 if there is a syntax error, it also applies two unit tests called file_uploads and expose_php, which will make the program output a warning and exit with status 2 if they are not met. The essential part of the rules is the expr parameter, which is an Augeas XPath expression. In this case, the expressions must not match any nodes in order to pass the tests (hence value=0).

These are just simple examples of what this module can do. You can find more examples shipped with the module itself. As a last example, here is one for Apache configuration files (in Debian/Ubuntu):


[DEFAULT]

lens=Httpd

pattern=.*/(sites-available/.*)|(apache2/.*\.conf)


[one_servername]

name=One ServerName per VirtualHost *

explanation=There should be only one ServerName per VirtualHost * entry

type=count

expr=$file[label() != "default"]/VirtualHost[arg =~ regexp("\*(:80)?")][count(directive[. = "ServerName"]) != 1]

value=0

level=warning



[bufferedlogs]

name=BufferedLogs

explanation=BufferedLogs must be set to Off

type=count

expr=$file//directive[. = "BufferedLogs"][arg = "On"]

value=0

level=warning

tags=security



[timeout]

name=Timeout

explanation=Timeout must be at least 45

type=count

expr=$file//directive[. = "Timeout"][int(arg) < 45]

value=0

level=warning

tags=security

Bible verses in Mint fortunes

2011-09-06T21:37:00.003+02:00

For my most recent computer, I've installed Linux Mint 11. In Mint, bash is set to display a fortune cookie every time you start a shell session.

This is a nice idea, however I would rather see daily Bible verses than random fortunes. Here is how to do that. First, install the verse package:



$ sudo apt-get install verse

Then, edit /usr/bin/mint-fortune with sudo, and replace the line:



/usr/games/fortune | $command -f $cow

with



/usr/bin/verse | sed -e 's@^ *@@' | $command -f $cow

To be sure that the file won't be overridden when you upgrade your distribution, set it as a local diversion:



$ sudo dpkg-divert --local /usr/bin/mint-fortune

and you're done!

Colored initials in LaTeX

2011-08-26T19:01:00.001+02:00

Georg Duffner, the creator of the EB Garamond open-source font, has been working on an initials font for EB Garamond based on a 16th century French Bible lately. A few days ago, he was thinking about producing colored initials with it, and had the idea of splitting the font in two: one font for the background ornament, and one font for the foreground letter to superimpose on it.

Base on this idea, I have hacked a little LaTeX module to typeset the initials in a simple way. The module can be found on github and is based on the lettrine LaTeX module.

It makes use of fontspec to load the fonts so it only works with XeTeX and LuaTeX.

The alphabet only contains 3 letters for now, so not really much can be achieved with it so far, but the code is there.

Here is an example reproducing parts of the 16th century Bible used to get the samples of the initials:

Keeping the Law — for whose sake?

2011-05-11T23:12:00.000+02:00

Ye hypocrites, well did Esaias prophesy of you, saying,

This people draweth nigh unto me with their mouth, and honoureth me with their lips; but their heart is far from me.

Matthew 15:7—8

Many times, Jesus called people — especially the Pharisees — hypocrites. This puzzled His disciples quite a bit, because the Pharisees where people who kept the Law strictly. How could people who kept the Law be wrong? Well, the problem is that they kept the Law outwardly but not inwardly.

I heard many comments on the subject over the years, but something about this struck me today. Who were the Pharisees keeping the Law for? For whose sake do we act the way we do? Jesus said that when you desire a woman, you've already committed adultery with her in your heart, and that when you insult someone — even in your heart — you've already committed murder.

What is it that keeps me from acting the thoughts I have? Why do I sometimes let myself desire a woman, but I won't commit adultery in real life? Let's face it: even a lot of non believers have never committed adultery, let alone murder. I think the problem is here: for whose sake do you act the way you do? For God's sake, or for your own?

Many people act properly for their own sake ; they are afraid of what people will think about them, or do to them, if they don't act nicely. They keep the Law for their own sake — because of fear, or because of pride — and they have no reason to keep their thoughts as clean as their acts.

Jesus called us to go much further than that. He said we should actually keep even our thoughts clean. Why? For God's sake! It's not so much that I should look like a perfect person, that I should care about what people think about me — if they will judge me, hate me, stone me — if I don't act properly. No, there's someone — God — who knows more about myself than I even do, and for His sake, I should be perfect, because He said : "Be ye therefore perfect, even as your Father which is in heaven is perfect" (Matthew 5:48).

As Christians, we so often tend to think that we can do it the easy way: starting by cleaning ourselves outwardly, and finishing with the inside. It doesn't work that way, because the goal is not the same. If you care to clean the outside first, you're doing it for your own sake, but cleaning the inside requires doing it for God's sake, for the inward cleaning is the work of the Holy Spirit in our lives.

Your motivation defines where you're heading. If you act the way you do for your own sake, you will stay stuck with the outward issues of your life. If you want to give it all to God and change for His sake, asking the Holy Spirit to cleanse you from the inside — even if it might take longer and be more painful — He will do this work in you, and it will end up showing up outwardly in your life.

Father Almighty,

I realize my own efforts to purify myself are vain because they are only motivated by fear and pride, and they do not cleanse me internally — for Your sake.

I pray Lord that you send your Holy Spirit in my life to achieve the work within me, that I may be perfected to your image inwardly, and shine of your glory outwardly.

In Jesus' name. Amen.

The fancytabs LaTeX package

2011-04-14T12:30:00.004+02:00

Lately, I've been using LaTeX quite a bit, and defining my own macros. Today is the occasion for me to release my first package: fancytabs.

This is a package that allows to add fancy tabs on the border of pages in a document.

The package can be downloaded from the CTAN.

Installing

After downloading and unzipping the file, run latex on the fancytabs.ins file. This will produce a fancytabs.sty file which provides the package. You can also build the PDF documentation by running pdflatex on the fancytabs.dtx file.

What does it look like?

Here is an example of a page featuring a fancy tab:

Syntax highlighting in LaTeX

2011-03-29T22:43:00.002+02:00

Lately, I have been busy making a book on Augeas. I wanted something that would look nice, and that would use only LaTeX.

A colleague of mine told me to have a look at the Pygments syntax highlighter and its LaTeX module minted. I'm very happy with them so far.

Installing Pygments

Installing Pygments on Ubuntu is as easy as can be:

$ sudo apt-get install python-pygments

This provides a /usr/bin/pygmentize command, which is then used by minted.

Installing minted

I didn't find a package for minted, so I downloaded the files from the CTAN and made a minted directory in my source.

When building with pdflatex, I make sure to export the TEXINPUTS=minted: variable so that pdflatex uses the minted directory for inclusions.

Adding syntax highlighting

Now that all the tools are installed, we need to actually use them in the LaTeX source. Here is a simple example:

\mint{console}|$ sudo apt-get install augeas-tools|

A multi-line example:

\begin{minted}{console}
$ sudo yum install readline-devel
$ sudo apt-get install libreadline-dev
\end{minted}

And even a listing example:

\begin{listing}
  \begin{minted}{augtool-shell}
/files/etc/foo.conf
/files/etc/foo.conf/#include = /etc/foo.d/*
  \end{minted}
  \caption{Augeas does not interpret include statements}
  \label{lst:intro_include_tree}
\end{listing}

There is much that can be done, and the documentation is well made.

I'm missing lexers

I would love my book to be full of colours. Not only for languages that are well known, but also, and especially, for the languages and commands that are specific to Augeas.

Of course, Pygments doesn't provide lexers for Augeas syntax (yet), so I need to write them.

The first lexer I would like to have is the augtool-shell lexer, which will put syntax highlighting on commands from an augtool session.

My lexer looks like this:

import re

try:
    set
except NameError:
    from sets import Set as set
from bisect import bisect

from pygments.lexer import Lexer, LexerContext, RegexLexer, ExtendedRegexLexer, \
     bygroups, include, using, this, do_insertions
from pygments.token import Punctuation, Text, Comment, Keyword, Name, String, \
     Generic, Operator, Number, Whitespace, Literal
from pygments.util import get_bool_opt
from pygments.lexers.other import BashLexer

__all__ = ['AugtoolShellLexer']


class AugtoolShellLexer(RegexLexer):
    """
    Lexer for Augtool shell sessions.
    """

    name = 'AugtoolShell'
    aliases = ['augtool-shell']
    filenames = ['*.augtoolshell']
    mimetypes = ['text/x-augtool-shell']

    tokens = {
        'root': [
            (r'^\s+$', Text),           # empty line
            (r'^[;#].*?$', Comment),    # comment
            (r'^(rm\s+:.*)', Text),     # removed nodes
            (r'^(Saved.*)', Text),      # saved
            (r'^(augtool\>)(\s+)(\S+)(?:(\s+)(.*))?$',   # augtool prompt
             bygroups(Generic.Prompt, Whitespace, Keyword, Whitespace, String)),
            (r'^([^=]+)(?:(\s+)(=)(\s+)(.*))?$',    # ls/get/print
             bygroups(String, Whitespace, Operator, Whitespace, String)),
            (r'^(\S+)(\s+)(label)(=)(\S+)(\s+)(value)(=)(\S+)(\s+)(span)(=)(\S+)$',  # span output
             bygroups(String, Whitespace, Keyword, Operator, String, Whitespace,
                                    Keyword, Operator, String, Whitespace,
                                    Keyword, Operator, String)),
        ]
    }

It is located in the augeas-lexer/augeaslexer/augeaslexer.py file, and the augeas-lexer directory contains the following files:

augeas-lexer/
├── augeaslexer
│   ├── augeaslexer.py
│   └── __init__.py
└── setup.py

__init__.py is an empty file, and setup.py contains the following:

"""
Augeas syntax highlighting for Pygments.
"""

from setuptools import setup

entry_points = """
[pygments.lexers]
augtool-shell = augeaslexer.augeaslexer:AugtoolShellLexer
"""

setup(
    name         = 'augeaslexer',
    version      = '0.1',
    description  = __doc__,
    author       = "Raphael Pinson",
    packages     = ['augeaslexer'],
    entry_points = entry_points
)

In order to build with this new lexer, I need to install it in my system (if someone knows how to do without this step, I'll be very happy to hear it!). The following command does that:

$ sudo python setup.py install

Now when I run pygmentize, I should see my lexer:

$ pygmentize -L | grep augtool
* augtool-shell:
    AugtoolShell (filenames *.augtoolshell)

I've actually added (or begun to add) 3 more lexers to my module: AugtoolLexer, AugeasLexer and PuppetAugeasLexer.

The result can be see in the PDF version of the book (which is still a work in progress).

Defining macros

One thing LaTeX users love is its flexibility. On big projects such as books, it is often useful to define macros and new environments.

Here is an example of a listing containing several languages with line numbering. The macros take care of applying the line numbering options (linenos and firstnumber) and defining the standard options for my document (fontsize=\footnotesize and bgcolor=bg).

The macros look like this:

% minted commands

\newcommand{\mymint}[3][]{\mint[fontsize=\footnotesize,bgcolor=bg,#1]{#2}#3}
\newcommand{\consolecode}[2][]{\mymint[#1]{console}#2}
\newcommand{\augtoolshcode}[2][]{\mymint[#1]{augtool-shell}#2}

% inputminted

\newcommand{\myinputminted}[3][]{\inputminted[fontsize=\footnotesize,bgcolor=bg,#1]{#2}{../listings/#3}}

And the listing:

\begin{listing}
  \consolecode[linenos]|$ augtool --backup --root myroot|
  \myinputminted[linenos,firstnumber=2]{augtool-shell}{rm_fstab_opt.augtoolshell}
  \consolecode[linenos,firstnumber=15]|$ diff -u myroot/etc/fstab myroot/etc/fstab.augsave|
  \myinputminted[linenos,firstnumber=16]{diff}{fstab_opt.diff}
  \caption{Removing an option in fstab}
  \label{lst:rm_fstab_opt}
\end{listing}

This produces the following output:

Changing a remote URL in git

2011-03-18T11:52:00.000+01:00

You cloned a git repository using a public URL, and now everytime you want to push to it, you have to specify the push R/W URL because the public URL you used to pull is read-only.

This happened to me:

$ git remote show origin 
* remote origin
  Fetch URL: git://git.fedorahosted.org/git/augeas.git
  Push  URL: git://git.fedorahosted.org/git/augeas.git
  HEAD branch: master
  Remote branch:
    master tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

and here is how I fixed it:

$ git remote set-url --push origin ssh://raphink@git.fedorahosted.org/git/augeas.git
$ git remote show origin 
* remote origin
  Fetch URL: git://git.fedorahosted.org/git/augeas.git
  Push  URL: ssh://raphink@git.fedorahosted.org/git/augeas.git
  HEAD branch: master
  Remote branch:
    master tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Note that the --push option modified only the push URL, so I keep using the public URL for fetching, which is fine.

Introducing Config::Augeas::Exporter

2011-02-25T23:13:00.000+01:00

Following my little experiments from two days ago, I decided to turn my prototype into a Perl module so others could benefit from it.

I am therefore happy to introduce Config::Augeas::Exporter, uploaded today to the CPAN. Packages are also available for Ubuntu Lucid and Natty in the Augeas PPA.

This module wraps up around Config::Augeas and currently provides 4 public export methods:

to_xml(): export the Augeas tree to an XML::LibXML::Document object ;
to_hash(): export the Augeas tree to a hash ;
to_json(): export the Augeas tree to a JSON document ;
to_yaml(): export the Augeas tree to a YAML document ;

In addition to this, it also provides a from_xml() method to import back an XML exported tree.

The module is shipped with two scripts, aug2xml and xml2aug, which are essentially the scripts presented in my previous blog entry, rewritten to use the module.

Thanks to the great advice of David Lutterkort, Augeas' main developer, the XML layout has been improved, which makes it much nicer, smaller, easier to parse, and much easier to import back.

As a result of this, xml2aug is now able to replace only the files listed in the XML document, instead of replacing the whole tree.

Here are some examples of what can be done with aug2xml and xml2aug:

# Let's export the pam.d files only, excluding the comment nodes
$ aug2xml -p '/files/etc/pam.d' -e "#comment"  > export.xml
# How many files where exported?
$ grep -o "<file" export.xml | wc -l
34
$ ls -lh export.xml 
-rw-r--r-- 1 raphink raphink 20K 2011-02-25 23:06 export.xml
# We can try some XPath requests on the file
# For example finding the control condition
# for the pam_env.so module in the cron rule
$ xpath -e '//file[@path="/etc/pam.d/cron"]/node[node[@label="module"]="pam_env.so"]/node[@label="control"]' export.xml 
Found 2 nodes in export.xml:
-- NODE --
required
-- NODE --
required
# Now let's import it back to a clean fakeroot
$ mkdir -p fakeroot/etc/pam.d
$ xml2aug -r fakeroot/ -f export.xml
$ tree fakeroot/
fakeroot/
└── etc
    └── pam.d
        ├── atd
        ├── chfn
        ├── chpasswd
        ├── chsh
        ├── common-account
        ├── common-auth
        ├── common-password
        ├── common-session
        ├── common-session-noninteractive
        ├── cron
        ├── cups
        ├── cvs
        ├── gdm
        ├── gdm-autologin
        ├── gnome-screensaver
        ├── kcheckpass
        ├── kdm
        ├── kdm-kde4
        ├── kdm-kde4-np
        ├── kdm-np
        ├── kscreensaver
        ├── login
        ├── newusers
        ├── other
        ├── passwd
        ├── polkit
        ├── polkit-1
        ├── ppp
        ├── samba
        ├── sshd
        ├── su
        ├── sudo
        └── xscreensaver

2 directories, 33 files

Augeas 0.8.0

2011-02-24T11:21:00.000+01:00

Right on time for Natty feature freeze, Augeas 0.8.0 has been released and is uploaded to Natty!

Packages are also available for Lucid and Maverick in the Augeas PPA.

What's new in Augeas?

Well, quite a bit. To begin with, thanks to the great work of Francis Giraldeau, the main change is the addition of a new "square" lens combinator, which makes it possible to write such lenses as XML or Apache. Francis has committed both xml.aug and httpd.aug.

Antoher improvement which I am sure will bear fruits in the future is the addition of the aug_span API call. This will allow developments such as augedit, which could greatly improve configuration management GUIs.

Augtool has also benefitted quite a bit from this release, gaining a few options:

--autosave makes sure to call "save" after all commands are issued ;
--interactive lets you run an interactive shell after intepreting the commands passed in a file or via STDIN (see this post for an example) ;
--nostdinc, --noload and --noautoload have gained short options, so they can be used with augtool as an interpreter (in a shebang).

With these improvements in augtool, you can now write a script like the following:

#!/usr/bin/augtool -Asif

set /augeas/load/Json/lens Json.lns
set /augeas/load/Json/incl /home/raphink/myjson.json
load

Make this script executable and run it, and you will get an interactive shell with only /home/raphink/myjson.json parsed (hence a very low loading payload due to the -A flag). The -s flag will ensure that "save" is called when you quit the shell.

What's new in the Ubuntu package?

Improvements have also been made in the last versions of the augeas package in Ubuntu. In 0.7.4, an augeas-doc package has been added. This package has been complemented in 0.8.0, so now it includes:

Generated API docs (with NaturalDocs) for the C API and lenses ;
Generated PDF docs about bx theory on lenses and ambiguity ;
Text docs about XPath expressions (see also the Augeas wiki).

Feedback

We love to know what you do with Augeas, and the ideas that you have to improve it. We also like to know when things don't work so we can fix them.

There are many ways to contribute to Augeas, so don't hesitate to join us!

Version number suggests Ubuntu changes

2011-02-24T09:45:00.000+01:00

Today, I was updating an Ubuntu package whose maintainer in Debian has a @canonical.com address.

When I was building the source package, I kept getting an error:

Version number suggests Ubuntu changes, but Maintainer: does not have Ubuntu address

This error crashed dpkg-source and prevented me from building the source package.

Upon looking into the code (/usr/share/perl5/Dpkg/Vendor/Ubuntu.pm), I found that this errors only when DEBEMAIL is defined in the environment with a @ubuntu.com address ; a warning is issued otherwise.

So if you ever have this problem, it's easily fixed by unsetting DEBEMAIL:

$ unset DEBEMAIL

Exporting the Augeas tree to XML

2011-02-23T09:00:00.000+01:00

While Augeas is usually used to modify configuration files (for example as a Puppet type), it can also be useful to request configuration files.

Sometimes, you might want to retrieve that information from several servers and gather it on a central machine or DB to request it later. Programs that permit this usually use several parsing modules or copy the configuration files verbatim.

aug2xml

Since Augeas can now parse a lot of configuration files, it could be useful to export its tree to a XML file that could be stored and used elsewhere.

The problem, however, is that the Augeas tree is not valid XML. Mainly, the nodes in Augeas can be numbers (in the case of "seq" nodes) or begin with such characters as "#". These names are illegal as node names in XML.

For this reason, I have chosen to map the nodes as "node" elements, and use a "label" attribute to store their label. The value of the nodes (where there is node) is stored in the text sub-node.

The following script is a prototype to export the Augeas tree to an XML file. On Debian and Ubuntu systems, you will need to install the libconfig-augeas-perl, libxml-libxml-perl and libencode-perl packages:

$ sudo apt-get install libconfig-augeas-perl \
    libxml-libxml-perl libencode-perl

Here is the script:

#!/usr/bin/perl -w

use strict;
use Config::Augeas;
use XML::LibXML;
use Getopt::Long;
use Encode;

my $path = '/files';
my $root = '/';
my $verbose;
my $debug;
my $help;

my $result = GetOptions (
   "path=s" => \$path,
   "root=s" => \$root,
   "verbose" => \$verbose,
   "debug" => \$debug,
   "help" => \$help,
   );

if ($help) {
   usage();
   exit 0;
}

$verbose ||= $debug;

my $aug = Config::Augeas->new(root => $root);
my $doc = XML::LibXML::Document->new('1.0', 'utf-8');

my $elem = aug2xml($path);
$doc->setDocumentElement($elem);
print $doc->toString;


#######
# Subs
#######

sub usage {
   print "$0 [-p ] [-r fakeroot] [-v] [-d] [-h]

 Flags:
   -h, --help             Show this help
   -v, --verbose          Verbose mode
   -d, --debug            Debug mode

 Options:
   -p, --path       Set path to export
   -r, --root   Set fakeroot for Augeas
";
}


sub aug2xml {
   my ($path) = @_;

   my $label = '';
   if ($path =~ m|.*/([^/\[]+)(\[\d+\])?|) {
      $label = $1;
   } else {
      warn "W: Could not parse $path\n";
   }
   my $elem = XML::LibXML::Element->new('node');
   $elem->setAttribute("label", $label);

   my $value = $aug->get($path);
   if(defined($value)) {
      $elem->appendTextNode(encode('utf-8', $value));
   }

   $path =~ s| |\\ |g;
   my @children = $aug->match("$path/*");

   for my $child (@children) {
      my $child_elem = aug2xml($child);
      $elem->appendChild($child_elem);
   }

   return $elem;
}

Having saved this code as aug2xml and made it executable, you can run:

$ ./aug2xml > export.xml

This should create an export.xml file which contains all the configuration files in your system that Augeas was able to parse.

Looking into the XML export

Now we've created the export.xml file, let's see how it looks. I've created mine from a fakeroot containing only fstab and aliases files, so it's not too big.

We can use tools such as xmlindent to view it nicely:

<?xml version="1.0" encoding="utf-8"?>
 <node label="files">
  <node label="etc">
   <node label="aliases">
    <node label="#comment">See man 5 aliases for format</node>
     <node label="1">
      <node label="name">postmaster</node>
      <node label="value">root</node>
     </node>
    </node>
    <node label="fstab">
     <node label="#comment">/etc/fstab: static file system information.</node>
     <node label="#comment">Use 'blkid -o value -s UUID' to print the universally unique identifier</node>
     <node label="#comment">for a device; this may be used with UUID= as a more robust way to name</node>
     <node label="#comment">devices that works even if disks are added and removed. See fstab(5).</node>
     <node label="#comment">&lt;file system&gt; &lt;mount point&gt;   &lt;type&gt;  &lt;options&gt;       &lt;dump&gt;  &lt;pass&gt;</node>
     <node label="1">
      <node label="spec">proc</node>
      <node label="file">/proc</node>
      <node label="vfstype">proc</node>
      <node label="opt">nodev</node>
      <node label="opt">noexec</node>
      <node label="opt">nosuid</node>
      <node label="dump">0</node>
      <node label="passno">0</node>
     </node>
     <node label="#comment">/ was on /dev/sda1 during installation</node>
     <node label="2">
      <node label="spec">UUID=4cbb4f80-45f9-4e46-a076-8ec1124f4835</node>
      <node label="file">/</node>
      <node label="vfstype">ext3</node>
      <node label="opt">errors
       <node label="value">remount-ro</node>
      </node>
      <node label="dump">0</node>
      <node label="passno">1</node>
     </node>
     <node label="3">
      <node label="spec">/dev/sda2</node>
      <node label="file">none</node>
      <node label="vfstype">swap</node>
      <node label="opt">rw</node>
      <node label="dump">0</node>
      <node label="passno">0</node>
     </node>
    </node>
   </node>
  </node>

Let's play with the XML export

So now we have an XML export of our configuration. What now? Let's try to make requests on it!

Because of the choices explained above which turn out every node to be named 'node', the Xpath request will be uglier than it would be had we used Augeas directly.

For example, let's say we want to get the file system type of the "/" entry in /etc/fstab. In Augeas, we could do:

$ augtool 'get //fstab/*[file="/"]/vfstype'
  //fstab/*[file="/"]/vfstype = ext3

That's straight-forward enough. Now let's try to do it from our XML file:

#!/usr/bin/perl -w

use strict;
use XML::LibXML;

my ($file) = @ARGV;

open (my $fh, "<$file") 
   or die "E: Could not open $file: $!\n" ;
my $doc = XML::LibXML->load_xml(IO => $fh);
close $fh;


print $doc->findvalue('//node[@label="fstab"]/node/
   node[@label="file"][child::text()="/"]/
   ../node[@label="vfstype"]')."\n";

Save this script as testaugxml, make it executable and run:

$ ./testaugxml.pl export.xml 
ext3

It works, although the Xpath expression is certainly uglier than in Augeas.

xml2aug

Now what if I wanted to import that XML file back to Augeas? That could be fun, and sometimes useful, too.

There's a problem here. Exporting the Augeas tree to a clean XML file is very simple ; importing it back is more complex, because of the existing tree.

Without getting into much details, we have roughly 3 possibilities:

xml2aug replaces the Augeas tree with the contents of the XML file, erasing the existing tree ;
xml2aug replaces the Augeas tree with the contents of the XML file only on files listed in the XML file and doesn't touch other files ;
xml2aug applies the XML file as a patch on the existing tree.

The 3^rd solution is very hard to implement, and the 2^nd solution might be possible once Augeas allows to get more information on nodes (knowing if the node is a directory, a file or a configuration entry would help). I'm left with the 1^st solution to implement my script for now.

This having been said, you have been warned: there is a --root option in this script, make use of it if you don't want to lose some configuration files!

Here is the script:

#!/usr/bin/perl -w

use strict;
use Config::Augeas;
use XML::LibXML;
use Getopt::Long;

my $file;
my $root = '/';
my $verbose;
my $debug;
my $help;

my $result = GetOptions (
   "file=s" => \$file,
   "root=s" => \$root,
   "verbose" => \$verbose,
   "debug" => \$debug,
   "help" => \$help,
   );

if ($help) {
   usage();
   exit 0;
}

$verbose ||= $debug;


unless (defined($file)) {
   die "E: You must specify a filename\n";
}

open (my $fh, "<$file") 
   or die "E: Could not open $file: $!\n" ;
my $doc = XML::LibXML->load_xml(IO => $fh);
close $fh;

my $aug = Config::Augeas->new(root => $root);
# we want to replace everything
$aug->rm('/files/*');
my @top_nodes = $doc->find('/*/node[@label != "files"]')->get_nodelist();

for my $node (@top_nodes) {
   xml2aug($node, '/files');
}

$aug->print('/files') if $debug;
$aug->save();
$aug->print('/augeas//error');


########
# Subs
########

sub usage {
   print "$0 [-f ] [-r fakeroot] [-v] [-d] [-h]

 Flags:
   -h, --help             Show this help
   -v, --verbose          Verbose mode
   -d, --debug            Debug mode

 Options:
   -f, --file       Set XML file to import from
   -r, --root   Set fakeroot for Augeas
";
}

sub xml2aug {
   my ($elem, $path) = @_;

   my $type = $elem->nodeType;

   my $label = $elem->getAttribute('label');

   my $matchpath = "$path/*[last()]";
   $matchpath =~ s| |\\ |g;
   my $lastpath = $aug->match("$path/*[last()]");

   if(defined($lastpath)) {
      print "V: Inserting $label after $lastpath\n" if $verbose;

      # Insert last node
      $aug->insert($label, "after", $lastpath);
   } else {
      $aug->set("$path/$label", '');
   }

   $matchpath = "$path/${label}[last()]";
   $matchpath =~ s| |\\ |g;
   my $newpath = $aug->match($matchpath);


   my $value;

   for my $child ($elem->childNodes()) {
      if ($child->nodeType == XML_TEXT_NODE) {
         # Text node
         $value = $child->nodeValue;
      } else {
         xml2aug($child, $newpath);
      }
   }

   if (defined($value)) {
      print "V: Setting value of $newpath to $value\n" if $verbose;
      $aug->set($newpath, $value);
   }
}

Future development

The current state of this prototype is a set of Perl scripts. Eventually, I would like to merge at least the export functionality in augtool, so as not to depend on Perl.

Manually associating lenses with files in Augeas

2011-02-18T22:59:00.000+01:00

Autoload statements and known files

Augeas comes with a good collection of lenses that allow to parse the most common configuration files. Lenses are bidirectional pieces of code which allow Augeas to parse a configuration file and turn its content into a tree. Most lenses have an autoload statement which associates them with a specific set of files. For example, mysql.aug is associated with /etc/my.cnf and fstab.aug is associated with /etc/fstab. When Augeas is loaded, it searches the system for files that it knows about and tries to parse them with the associated lenses.

Lenses without autoload statements

In some cases though, lenses are not associated with specific files through an autoload statement. This is the case for generic modules, such as util.aug, sep.aug, rx.aug, build.aug or inifile.aug, but also for lenses for which we do not know specific configuration files in a standard system. Such is the case of json.aug, since JSON is used a lot to serialize data between two programs, but hardly as static configuration files. Augeas has a JSON lens, but it is not associated with any known file.

How to use lenses without autoload statements

How then, would you go about using the JSON lens on a file of your choice? There are several possibilities. Let's say you have a JSON file called foo.json located at /home/bar/foo.json and you want to parse it using augtool.

Manipulating Augeas metadata on-the-fly

Augeas provides two root nodes in its tree: "/files" and "/augeas". The former lists the files Augeas was able to parse with its set of lenses, while the latter provides access to Augeas' metadata. In this last part of the tree, lenses can be manipulated on-the-fly.

Let's launch augtool and add /home/bar/foo.json to the JSON lens:

# --noload deactivates all known lenses to make augtool faster
$ augtool --noload
> # json.aug is not loaded by default, set it up
> set /augeas/load/Json/lens Json.lns
> # Add to /home/bar/foo.json to the known files
> set /augeas/load/Json/incl /home/bar/foo.json
> # Load known files
> load
> print /files/home/bar/foo.json

From the (soon to be released) 8.0.0 version of Augeas, a -i flag will be available in augtool allowing to interpret a file before launching an interactive augtool shell. With this option, it will be possible to set a file with the previous contents and use it as an argument to augtool:

$ cat json_foo.augtool
# json.aug is not loaded by default, set it up
set /augeas/load/Json/lens Json.lns
# Add to /home/bar/foo.json to the known files
set /augeas/load/Json/incl /home/bar/foo.json
# Load known files
load
$ augtool --noload -if json_foo.augtool
> print /files/home/bar/foo.json

Creating a derived lens for the file

Augeas allows lenses to use definitions declared in other lenses. This is how generic modules are made to make lens development easier. It also allows you to make your own lenses, derived from existing lenses.

In our case, we could write a lens and use it:

$ cat jsonfoo.aug
module JsonFoo =
   autoload xfm
   let filter = incl "/home/bar/foo.json"
   let xfm = transform Json.lns filter
$ augtool -I . 
> print /files/home/bar/foo.json

In Debian and Ubuntu systems, lenses provided with Augeas are placed in /usr/share/augeas/lenses/dist, so you can place your own lenses in /usr/share/augeas/lenses without a risk of overriding them.

Other lenses

These techniques apply to all lenses provided by Augeas. If you have a PHP configuration that is not in a standard path, you can use them to manipulate this file.

Spams of a new kind: this one might deserve a visit to the police

2010-12-18T20:03:00.000+01:00

Today, I received this nice spam (which was not flagged by the spam detecting system actually):

from Pat Wages

to

date Sat, Dec 18, 2010 at 3:07 PM

subject ASSASIN I HAVE BEEN PAYED TO TERMINATE YOU.

signed-by sbcglobal.net

This is the only way I could contact you for now, I want you to be very careful about this and keep this secret with you until I make out space for us to see. You have no need of knowing who I am or where I am from. I know this may sound very surprising to you but it's the situation. I have been paid some ransom in advance to terminate you with some reasons listed to me by my employer. It's someone I believe you call a friend; I have followed you closely for a while now and have seen that you are innocent of the accusations he leveled against you. Do not contact the police or try to send a copy of this to them, because if you do, I will know, and I might be pushed to do what I have been paid to do. Besides, this is the first time I turn out to be a betrayer in my job. I took pity on you, that is why I have made up my mind to help you if you are willing to help yourself.

Now listen, I will arrange for us to see face to face, but before that, I need $9,000. I will come to your home or you determine where you wish we meet; I repeat, do not arrange for the cops and if you play hard to get, it will be extended to your family. Do not set any camera to cover us or set up any tape to record our conversation; my employer is in my control now. Payment details will be provided for you to make a part payment of $3,000 first, which will serve as guarantee that you are ready to co-operate, then I will post a copy of the video tape that contains his request for me to terminate you which will be enough evidence for you to take any legal action against him before he employs another person for the job. You will pay the balance of $3,000 once you receive the tape.

Warning; do not contact the police, make sure you stay indoors once it is 7.30pm every day until this whole thing is sorted out, if you neglect any of these warnings, you will have yourself to blame. You do not have much time, so get back to me immediately

Note: I will advise you keep this to yourself alone, not even a friend or a family member should know about it because it could be one of them.

Reply Me To My Personal Email: CUTSYCAT@LIVE.COM

Now sometimes I find spam quite funny, but this one is really serious. I mean, I know enough people who can't tell what is spam and what is not to take this email seriously, and this is a grave subject. From checking on Google, it seems quite a few other people received this email lately. The police might not be willing to investigate on viagra spam, but this one deserves some research I think.

Building docs with NaturalDocs

2010-11-22T13:57:00.000+01:00

I mentionned NaturalDocs in an earlier post on this blog since we're using it to document the Augeas C API and Augeas lenses.

With the latest version of Augeas now out, I wanted to get these docs generated with the package so they could be shipped in an augeas-doc package in Debian and Ubuntu. I first had to fix a missing link in the naturaldocs package (which was also the occasion to upgrade it to 1.5). Then I had to get naturaldocs in main, since augeas is in main already. While going through the MIR, I was asked if other packages in main could benefit from this change. I haven't found any, but there's quite a few packages in universe that could use naturaldocs to generate documentation at build time. The bug report lists some of them.

If you're interested in building NaturalDocs documentation in your package, here is the way it was done for Augeas.

Augeas is a C project using autotools. It was thus easier to activate NaturalDocs as an option in configure. This can easily be adapted for other cases, including running the commands in debian/rules directly.

In configure.ac:

dnl Check for NaturalDocs
AC_PATH_PROGS([ND_PROG], [naturaldocs NaturalDocs], missing)
AM_CONDITIONAL([ND_ENABLED], [test "x$ND_PROG" != "xmissing"])

dnl NaturalDocs output format, defaults to HTML
ND_FORMAT=HTML
AC_ARG_WITH([naturaldocs-output],
  [AS_HELP_STRING([--with-naturaldocs-output=FORMAT],
    [format of NaturalDocs output (possible values: HTML/FramedHTML, default: HTML)])],
  [
    if test "x$ND_PROG" = "xmissing"; then
      AC_MSG_ERROR([NaturalDocs was not found on your path; there's no point in setting the output format])
    fi
    case $withval in
       HTML|FramedHTML)
          ND_FORMAT=$withval
          ;;
       *)
          AC_MSG_ERROR($withval is not a supported output format for NaturalDocs)
          ;;
    esac
  ])
AC_SUBST(ND_FORMAT)

In doc/naturaldocs/Makefile.am:

EXTRA_DIST = $(wildcard conf/Augeas.css conf/c_api/*.txt) \
             $(wildcard conf/lenses/*.txt) \
             Modules/NaturalDocs/Languages/Augeas.pm

ND_CONF=$(srcdir)/conf
ND_OUTPUT=output
ND_STYLE=../Augeas

ND_PERL5LIB=$(abs_srcdir)/Modules
ND_PERL5OPT='-MNaturalDocs::Languages::Augeas'

if ND_ENABLED
all-local: NaturalDocs
endif

NaturalDocs: NDLenses NDCAPI

env:
 echo LIB $(ND_PERL5LIB)
 echo OPT $(ND_PERL5OPT)
 test -n "$$PERL5OPT" && ND_PERL5OPT="$(ND_PERL5OPT) $$PERL5OPT" || ND_PERL5OPT=$(ND_PERL5OPT); \
 test -n "$$PERL5LIB" && ND_PERL5LIB="$(ND_PERL5LIB):$$PERL5LIB" || ND_PERL5LIB=$(ND_PERL5LIB); \
        PERL5LIB=$$ND_PERL5LIB PERL5OPT=$$ND_PERL5OPT env | grep PERL

NDLenses: NDConf
 @mkdir -p $(ND_OUTPUT)/lenses
 @(echo "Format lens documentation"; \
   test -n "$$PERL5OPT" && ND_PERL5OPT="$(ND_PERL5OPT) $$PERL5OPT" || ND_PERL5OPT=$(ND_PERL5OPT); \
   test -n "$$PERL5LIB" && ND_PERL5LIB="$(ND_PERL5LIB):$$PERL5LIB" || ND_PERL5LIB=$(ND_PERL5LIB); \
   PERL5LIB=$$ND_PERL5LIB PERL5OPT=$$ND_PERL5OPT \
          $(ND_PROG) -p conf/lenses \
       -i $(top_srcdir)/lenses \
       -o $(ND_FORMAT) $(ND_OUTPUT)/lenses \
       -s $(ND_STYLE))

NDCAPI: NDConf
 @mkdir -p $(ND_OUTPUT)/c_api
 @(echo "Format C API documentation"; \
   test -n "$$PERL5OPT" && ND_PERL5OPT="$(ND_PERL5OPT) $$PERL5OPT" || ND_PERL5OPT=$(ND_PERL5OPT); \
   test -n "$$PERL5LIB" && ND_PERL5LIB="$(ND_PERL5LIB):$$PERL5LIB" || ND_PERL5LIB=$(ND_PERL5LIB); \
   $(ND_PROG) -p conf/c_api \
     -i $(top_srcdir)/src \
     -o $(ND_FORMAT) $(ND_OUTPUT)/c_api \
     -s $(ND_STYLE))

NDConf:
 @(if test ! -d $(ND_CONF); then \
     cp -pr $(ND_CONF) conf; \
   fi)

clean-local:
 rm -rf output conf/Data
 rm -rf $(ND_CONF)/c_api/Data $(ND_CONF)/lenses/Data

After that, the NaturalDocs docs can be built by calling --with-naturaldocs-output=HTML or --with-naturaldocs-output=FramedHTML.

I hope this can be useful to improve the shipped documentation for projects already using NaturalDocs.

Screen resolution with nVidia driver in Lucid

2010-10-11T10:21:00.000+02:00

I struggled recently with a bug on a desktop running Lucid. Whenever I would log in, I got a session set to 1024x768. I would go to the nvidia-settings, reset it to 1280x1024 and it would be fine. As I didn't have much time for it and logged in only once a week or so, I kept doing this for some time, but it ended up bugging me quite a bit. Then this morning, I found this bug report.

So if you're experiencing this bug, it's very easy to fix:

Edit your ~/.config/monitors.xml
Adapt it to your configuration (in my case, that's 1280x1024 and a rate of 60Hz).
Log out and back in.

Matching a mac address

2010-10-04T22:52:00.000+02:00

If it's of any use to someone, here is a regexp that matches mac addresses:

/[0-9A-Fa-f]{2}(?P<sep>[-:])[0-9A-Fa-f]{2}(?:(?P=sep)[0-9A-Fa-f]{2}){4}/

Example usage:

$ python
 >>> reg = re.compile('[0-9A-Fa-f]{2}(?P<sep>[-:])[0-9A-Fa-f]{2}(?:(?P=sep)[0-9A-Fa-f]{2}){4}')
 >>> mac1 = "00:af:15:35:48:5e"
 >>> mac2 = "00-aa-bb-cc-dd-ee"
 >>> mac3 = "00-aa-bb-cc-dd:ee"
 >>> reg.match(mac1).group(0)
'00:af:15:35:48:5e'
 >>> reg.match(mac2).group(0)
'00-aa-bb-cc-dd-ee'
 >>> reg.match(mac3).group(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
 >>> reg.match(mac1).group('sep')
':'
 >>> reg.match(mac2).group('sep')
'-'

Do you use another regexp to match mac addresses?

Getting block position in Javascript with Chrome

2010-09-18T10:48:00.000+02:00

Dear Lazyweb,

Yesterday, I had fun implementing a little ducky that hides on the pages of this website. To my distress, I ended up having to hardcode a few things, since I couldn't get Chrome to properly give me the real position of relative blocks. After reading quite a few things on the subject, I went the parentOffset recursive way, but it just doesn't seem to work.

I've also posted on StackOverflow here if you feel like answering me there.

Does anyone know of a cross-browser way of getting real block positions that actually works?

Helping young children learn to read

2010-09-17T18:00:00.000+02:00

Learning to read is a complex task. European children surely have it easier than many Asians who need to learn long series of ideograms, yet the association of signs and sounds is often difficult. In particular, English and French are two examples of European languages where children struggle to learn to read.

In these two languages, and even more so in English, there are more sounds than available letters, so the language ends up with complex associations of letters to produce sounds, and it is not rare to find letters or associations of letters that are pronounced differently in different words, even though they are written the exact same way.

This has led both English and French teachers of young children to develop new techniques to learn to read, based on recognizing whole words instead of phonemes. English teachers called it 'Look Say' (also known as 'Sight Word' or 'Whole-Word') method, while in France it was called 'Méthode globale'. These methods were used extensively in the 80s, often with very mitigated results. While children were able to read common words, however complicated their phonemes were, they often lacked the skills to decipher words they had not yet learned, and those were many.

The early 21st century has seen a return to reading basics, namely a revival of the 'Phonics' method, widely used before the era of the 'Look Say' last century. It is true that some words eventually have to be learned the global way, but most words can be learned phoneme by phoneme, if the method used is properly set. In the UK, the government has made a set of recommendations as to how this method should be implemented to teach young children to read.

The British editor of children books Usborne produces a series of 15 books called 'Very First Reading' to help children who are just starting to read, introducing letters by sets, as recommended by the DfES Letters and Sounds phonics programe. In the first books of the series, children are simply encouraged to complete the story read by an adult by reading simple words. As the child moves on in the series, the part read by the adult diminishes, until the whole story is read by the child alone.

In the open-source world, we have good programs to help children start reading, too. Gcompris is a great example of such programs for young children, and it takes phonics into consideration in its modules.

Do you teach your young children to read? What books or methods do you use for this?

Usborne Books on the Riviera

2010-09-13T21:07:00.000+02:00

Today, I am very happy to announce that my wife is starting a business here on the French Riviera. She loves the children books by the British editor Usborne, so she will be selling them at homes in the region.

Feel free to drop by her website and check the next days for Book Parties!

Flammard is an official Wave extension

2010-06-11T11:27:00.000+02:00

Flammard was approved in the Extensions gallery on Google Wave. This means you can now add it by going to "Extensions -> All" in the Navigation column.

Quite a few changes have been made to it in order to get it accepted, mostly on the gadget style. The gadget now has tabs and a nicer look.

Enjoy!

Flammard v2 is out

2010-06-03T14:38:00.000+02:00

After 6 months of loyal services, it was time for the Flammard Bible bot version 1 to leave.

Several reasons pushed me to rewrite the bot:

I had begun to rewrite the underlying modules used by the bot and wanted to use them;

I wanted to have a go at Natural Language Processing and get rid of all (or as many as possible) tags;

Finally, the robot API for Google Wave was updated, leaving me with a code that depended on an obsolete API. That was the spark to get me started;

In short, version 2 of the Bible bot:

Has no '<blah>', 'v/blah/' or 'vl/blah/' tags. It just recognizes Bible references in the text and processes them automatically. The only bit of a tag that persists is 'q' or 'quote' in front of a verse reference, such as 'quote gen 1:3', which tells the bot to quote the verse instead of just making it a link to an external website;

Comes with a Wave gadget to configure it which replaces the '<bible>' and '<pref>' tags.

Two pretty much unused functionalities were dropped in version 2:

The '<votd>' tag has no equivalent. My logs showed that nobody was using it. If you still want it, ping me. I might replace it with a Wave gadget once I expose the Flammard API publicly;

It is no longer possible to set the default Bible version per language, you can only set one default version per Wave.

You can install the bot by visiting this wave.

Wave Bible Bot

2009-11-14T13:38:00.000+01:00

After a month of using Google Wave, I finally made my first Wave bot. My initial idea was to make a Bible bot using the sword API, but I couldn't find an easy way of doing that in python, and I am very reluctant to use Java. So instead, I did a python bot which parses BibleGateway.com to retrieve the results. Later, I added modules to deal with other translations, such as ESV, NET and specific French versions such as Colombe, TOB or NBS.

What does it do?

Flammard is a Bible bot for Google Wave. You can add it to a wave, and it will replace some specific patterns with other content.

Currently, it recognizes two kinds of patterns:

<verse verseReference [from Version]> is replaced by the verse. The version is optional. Examples: <verse Gen 1:1 from NIV> or <verse Acts 3:5-15>
<verselink verseReference [from Version]> is replaced by a link to the verse on another website. The version is optional. Examples: <verselink Gen 1:1 from NIV> or <verselink Acts 3:5-15>

Known versions

The Bible bot uses several resources in order to support as many Bible versions as possible.

The versions currently supported are:

All versions from BibleGateway.com, referenced by their code (e.g. KJV, NIV, LSG) or their ID (the full list can be found on this page);
The ESV (English Standard Version) Bible;
The NET Bible, from Bible.org;
The BFC (La Bible en francais courant), PDV (Parole de Vie), Colombe (La Colombe), NBS (Nouvelle Bible de Segond), TOB (Traduction OEcumenique de la Bible) from La-Bible.net.

In all cases, the version is optional. When possible, the bot will try to find the right version for your blip depending on the language you have typed in the context of the tag.

Example

Live demo

Here is a video demo of the bot working (as of today's functionalities):

How can I add this bot to a wavelet ?

Simply add flammard@appspot.com as a participant to your wavelet.

Where can I find the source code?

The project is hosted on Launchpad: https://launchpad.net/wavebiblebot. You are welcome to report bugs and wishes, or to send patches.

Dynamic presentations with Jessyink

2009-10-12T21:38:00.000+02:00

Some time ago, I attended a presentation made with Prezi and I was pretty impressed. As I looked into it, a few things bugged me though:

it's in flash

I can't really share my presentations with anyone

I have to design my slides online, or use an offline app (paid) which will connect online

There is no good support for full screen presentations in Linux

It doesn't use a portable format

From looking at the features, I really couldn't see why it couldn't be implemented using SVG (except for the flash movies embedded in the presentation maybe...), so I began to search for a project that would do the same, using SVG, and I found Jessyink.

Jessyink is exactly what I was searching for. It's a plugin for Inkscape which adds the possibility to design slides from an SVG, and ships a javascript library inside the resulting SVG for execution. The result is that:

It's portable: apps that understands SVG and javascript can play it (e.g. Firefox, on any platform. Arora did fine too, but Konqueror wouldn't work)

It's an open format, with open standards: I can send the svg to someone, and they can edit it with inkscape using the Jessyink plugin

The possibilities are endless: I'm not limited to styles and fonts found on prezi.com, I can choose whatever font I want, whatever style I want

It's open-source!

It not only supports prezi-like effects inside slides, but also traditional slides, that can each behave like prezi-like presentations

Jessyink is harder to use than prezi.com though, but if you know how to use Inkscape, you will soon be able to do what you want with it.

Here is a quick & dirty example I made with Jessyink. Some tips:

Use the arrows to navigate through the presentation

Use the 'i' key to get an index of the slides (two slides in that case)

Use the 'd' key to draw on the presentation as you go through it!

See this page for more tips!