Building your own RaspBSD images in the cloud

RaspBSD is a great way to get some hands on experience with FreeBSD without any need to touch your local system. But RaspBSD is based on the FreeBSD 11-CURRENT branch, which is under active development.

So at some point I wanted to build my own SD card image, but compiling on your local machine can be very time consuming, which is why I used a cloud service for that.

The following guide was created using a virtual FreeBSD instance from DigitalOcean, but should also work on any other service like EC2 or on your local FreeBSD machine.

1. Create a new FreeBSD instance and login

Go to https://www.digitalocean.com (referal link, feel free to not use it) and sign up.

Create a new instance (they call it “droplet”) and choose FreeBSD 10.2. The size just depends on how long you are willing to wait. Note: you can resize your instance late to use more cores and ram.

Now, login via ssh.

2. Install all prerequisites

Let’s start by installing all the necessary software:

sudo portsnap fetch extract
sudo portsnap fetch update

sudo pkg install -y git nano tmux python u-boot-rpi

Now, start a tmux session because the following commands can be a bit long running:

tmux new

We’ll need the most recent FreeBSD source code:

sudo svnlite checkout svn://svn.freebsd.org/base/head /usr/src
sudo svnlite update /usr/src

The crochet-tool is used to handle the compiling and generation of the SD card image:

git clone https://github.com/freebsd/crochet.git ~/crochet

3. Configure and Compile the image

First create a config file and edit to your needs:

cd ~/crochet
cp config.sh.sample config.rpi.sh
nano config.rpi.sh

The config file is pretty straight forward, uncomment the type of board you are building for and if you don’t know better keep the default options.

The following command starts the compile process and can take very long. (Between 20 min and a couple of hours, depending on which instance type you chose.)

/bin/sh crochet.sh -c config.rpi.sh

4. Download your image and transfer to your SD card

The crochet.sh-script will output the name of your brand new SD card image.

Now download it to your local machine and copy it to the SD card:

sudo dd if=FreeBSD-armv6-11.0-RPI-B-297268.img of=/dev/disk2 bs=1m

Enjoy!

Updating your DNS records with inwxupdate.rb

I’m running a couple of Raspberry Pis in my closet that are connected to the rest of the world by IPv6. For the obvious reasons each has its own DNS record at my favorite Registrar InterNetworX INWX.

Unfortunately the my ISP thinks it is a good idea to rotate IPv6-prefixes to keep my devices secure.

To get around this circumstance I’ve build a small script to keep the IP-addresses updated.

Feel free to use and fork inwxupdate.

This is how you use it:

gem install inwxupdate

You can update multiple DNS records at a time and get IPs from different network interfaces.

# inwxupdate.config.rb
CONFIG = {
  inwx_api: 'api.domrobot.com',
  inwx_user: 'your_username',
  inwx_pass: 'your_password',
  jobs: [
    {
      records: [
        { name: 'www.example.org', type: 'AAAA' },
        { name: 'v6.example.org', type: 'AAAA' }
      ],
      detector: {
        type: 'ifconfig',
        version: 6, # detect IPv6 address
        network_interface: 'en0'
      }
    },
    {
      records: [
        { name: 'v4.example.org', type: 'A' }
      ],
      detector: {
        type: 'ipify',
        version: 4, # detect IPv4 address (ipify does not support IPv6)
        network_interface: 'en0'
      }
  ],
  debug: false
}

Then run:

inwxupdate

Update: You can now use different Detectors for obtaining your IP address. See example config.

New Side Project: Big Boy, Small World

Defining Functions dynamically in Javascript

Change TextMate Tabs with Two Finger Swipe on Magic Mouse

Yesterday I bought me an Apple Magic Mouse and the feature of using gestures for navigation in Safari an other apps really thrilled me.

So I wanted to use the Left/Right Swipe in TextMate to change my current file tab.

What I found was Bryan Schuetz’ tutorial on how to setup Multiclutch on Snow Leopard. Here

So go through the tutorial and you can configure gestures by application context.

So drop me a comment if you have your own productivity improving gestures.

How and why to set up a git mirror script

Today I had some issues with GitHub and the university's network. We run a Hudson continuous integration server behind a HTTP proxy that has to fetch revisions from a github repository.

But the problem was that the GitHub HTTP cloning is kind of broken at the moment. So I set up a little mirror script on my root server to mirror the GitHub repo to Gitorious.

Idea:

Solution:

Now the Hudson server can fetch from the Gitorious repo that is always in sync.

I know I could host all the stuff on my own server but I was to lazy to look up and setup all this server stuff. This solution took me about 10 minutes.

My conclusion: distributed version control is the shit!

TextMate tidbit: insert encoding in ruby files

Want to insert an encoding comment into your ruby code?

Do it TextMate style and create a snippet:

I know this is very static but I had not much time and decided for the simplest solution. I tried to read the actual encoding of the file you are inserting in, but always got "US-ASCII" insted of "UTF-8". So if you know better tweet me.

New Playground: Ruby 1.9.1 running Nginx and passenger

Last week I got some time to try out Phusion's new Nginx-module. So I decided to try out it's Ruby 1.9 compatibilty, to test my own projects wether they are Ruby 1.9.1 compliant or not.

I installed it on a fresh Ubuntu 9.04 RC1 Image into my virtual Box, and everything seems to work good yet.

So here is my Install log:

Installing Ruby 1.9.1

based on: http://www.rubyhead.com/2009/01/14/installing-ruby-191-from-source-on-ubuntu-screencast/

Download from it from here: ttp://www.ruby-lang.org/en/news/2009/01/30/ruby-1-9-1-released/

Installing Rails & Setting up a Sample App

Installing Nginx & Passenger

based on: http://blog.phusion.nl/2009/04/16/phusions-one-year-anniversary-gift-phusion-passenger-220

and insert:

Et voilá, open your browser and and see an new Rails App. Opening the environment page you can see that everything is running under Ruby 1.9.1.

I hope you enjoyed this how-to. Please feel encouraged to give me some feedback via twitter or e-mail.

Servermonitoring via Twitter

Da neulich mal wieder der Varnish-Cache abgerotzt ist und es dadurch wieder eine unerwartete Server-Downtime gab, dachte ich mir es wäre doch mal ganz nett über so etwas benachrichtigt zu werden. Und zwar am besten über mein Liebling-"Protokoll" Twitter.

Erst vor kurzem lief mir folgender Artikel zu Twibot, einem Ruby-Framework für die Twitter-API über den Weg. Also gesagt - getan, folgendes Script habe ich mir mal zusammen gehackt.

Das ist bestimmt nicht schön programmiert, aber es funktioniert. Konfiguriert wird es über die Datei ./config/bot.yml, aber am besten ist, ihr checkt es euch einfach auf Github aus: http://github.com/Santino/monbot/tree/master

Man kann den Bot einfach in einem bestimmten Intervall per Cron aufrufen und fertig ist die Karre.

Hiermit ist jeder herzlich eigeladen das Teil zu pimpen und noch andere Monitoring-Fälle einzubauen.

Was ist eigentlich Intelligenz?

Ich saß heute in der Vorlesung ‘Grundlagen der Wissensverarbeitung’, als mir ganz plötzlich eine sehr schöne Definition für Intelligenz entgegen sprang.

Um ganz genau zu sein, beschreibt sie eigentlich den Prozess der Informationsverarbeitung. Ich fand darin aber eigentlich die fünf wichtigsten Stufen menschlichen Handelns wieder.

Erkennen

Wenn es eine Aufgabe gibt, auf die das menschliche Gehirn richtig gut trainiert ist, dann auf die Erkennung von Mustern. Ob diese sich nun in Form von geometrischen Formen, Klangschemata oder wiederkehrenden Handlungsweisen auftreten ist dabei eher zweitrangig. Der erste Schritt zu intelligentem Handeln ist die Feststellung von Sachverhalten.

Schlussfolgern

Auch der zweite Schritt scheint noch recht einfach. Haben wir erst einmal ein Muster erkannt, können wir daraus Thesen oder Regeln aufstellen um Voraussagen zu treffen. Diese Regeln sind meist nur vages Wissen, sie sind also mit Wahrscheinlichkeiten belastet und lassen noch Spielraum für Interpretation.

Entscheiden

Auf Grund dieser vagen Regelbasis fällt es oft schwer Entscheidungen zu fällen. Das Fällen von Entscheidungen ist also abhängig davon wie ausgeprägt und differenziert die Wissens- und Regelbasis ist. Es ist also nichts anderes als das Aufaddieren der Wahrscheinlichkeiten aller möglichen Wege – man nehme den Weg mit der größten Aussicht (Wahrscheinlichkeit) auf Erfolg.

Planen

Scheint eigentlich nichts weiter zu sein als ein Entscheiden auf Vorrat. Also quasi der Voraussage von Ereignissen auf Grund der Regelbasis. Dies ist nur durch eine umfassende und gefestigte Wissensbasis möglich da sich sonst die Möglichkeiten des Ausgangs sehr weit streuen und es eher ein Raten wird.

Lernen

Die Königsdisziplin. Aus den Ergebnissen der ersten vier Schritte kann man nun wieder neue Muster erkennen und neue Schlussfolgerungen ziehen. Dieser ganze Intelligenzprozess ist also auch noch iterativ und selbstjustierend, da ich die Ergebnisse meines Handelns immer wieder als Grundlage für neue Handlungen nehme.

Das alles erscheint mir eigentlich ganz logisch, und ist für mich eine gute Erklärung für einige ganz selbstverständliche Prozesse. Ich hoffe meine Ausführung enthält keine allzu groben Fehler. Wer mehr weis möge mich korrigieren.