Ich habe mich entschieden den Großteil meiner Datenbanken zu InnoDB umzuwandeln. Welche Vor- und Nachteile das hatt sollte sich jeder vorher klarmachen. Stichwort: ACID und Fulltext-Search. Natürlich könnte man einfach mit ALTER arbeiten. Aber ich wollte nicht umbedingt die alten MyISAM Tables noch im FS liegen haben. Also alle Datenbanken droppen und den geänderten Dump wieder einspielen, sodass die Tables neu (mit InnoDB) angelegt werden.

Zuersteinmal eine Liste mit den generieren mit den Datenbanken die man Bearbeiten möchte. Es ist zu beachten, dass man den mysql Table selbst nicht auf InnoDB umstellen möchte.

mysql -u root -p -e "show databases;" -N --batch | grep -v ^information_schema$ | grep -v ^mysql$

Die Liste der Datenbanken wird nachher noch hilfreich sein. Danach will man wahrscheinlich erstmal alle Dienste beenden, die auf dem MySQL zugreifen (Apache, Tomcat, whatever). In der my.cnf habe ich dann folgende Optionen für die InnoDB spezifiziert.

defaulot-storage-engine = InnoDB
innodb_buffer_pool_size = 16M
innodb_additional_mem_pool_size = 2M
innodb_log_file_size = 5M
innodb_log_buffer_size = 8M
innodb_flush_log_at_trx_commit = 1
innodb_lock_wait_timeout = 50


Anschliessend den Dump erstellen und alle ENGINE=MyISAM durch InnoDB ersetzen:

mysqldump -u root -p > all-databases.sql
sed -i -e 's#ENGINE=MyISAM#ENGINE=InnoDB#g' all-databases.sql

Vorsicht. Hier ist mysql als Datenbank mit gedumped! Mir ist dabei keine wirklich einfache Zeile eingefallen die mit Suche/Ersetze Spielchen mysql ausschliesst. Es gibt bei mysqldump die Option “–ignore-table=” aber auch hier hätte ich jeden mysql Table einzeln nennen müssen. Ich hab die Datenbank dann einfach per hand aus dem Dump herausgelöscht.

Außerdem sollte man seinen Datenbank Dump nach FULLTEXT durchsuchen, da dieser von InnoDB nicht unterstützt wird. In meinem Fall hat es nur ein altes Forum das niemand mehr benutzt betroffen, weshalb ich die Zeile einfach löschen konnte.

grep "FULLTEXT" all-databases.sql

Um jetzt alle Datenbanken zu droppen hab ich mir folgende Line gebastelt:

for x in $(mysql -u root -phierstehteinpasswort -e "show databases;" -N --batch | grep -v ^information_schema | grep -v ^mysql$) ; do mysql -u root -phierstehteinpasswort -e "drop database $x ; " --batch ; done

Nach der Bearbeitung kann man den Dump mit der neuen Engine für die Tables wieder einspielen:

mysql -u root -p < all-databases.sql

Ich dachte es wäre eine gute Idee einfach ein paar md5 Summen zu bilden.

$ time seq 1 10000 | parallel 'echo {}| md5sum &> /dev/null '
real 0m20.102s
user 0m35.082s
sys 0m24.918s

Nun. Ich bilde nicht so oft 10.000 md5 Summen. War das jetzt viel? Oder wenig? Um einen Vergleichswert zu haben sollte ich wohl auch mal nachsehen, wie das ohne Parallel so aussieht.

$ time for x in $(seq 1 10000); do echo $x | md5sum &> /dev/null; done
real 0m13.504s
user 0m2.368s
sys 0m3.948s

Ziemlich seltsam. Obwohl ich 10.000 md5 Summen gebildet habe war die sequenzielle Methode schneller als die Parallele. Zumindest dachte ich zu dem Punkt noch das es seltsam ist. Aber an was lag das. Ich hab mir dann überlegt ob ich nicht vielleicht doch noch eine andere Aufgabe als md5 Summenbildung abbilden sollte. Ich entschied mich dazu 1000 mal eine 100.000 Zeichen lange Zeichenkette durch gzip zu schubsen.

$ time seq 1 1000 | parallel 'cat /dev/urandom | head -c 100000 | gzip &> /dev/null'
real 0m7.845s
user 0m4.064s
sys 0m20.485s

7 Sekunden. Sieht eigentlich ganz nett aus. Und in der Schleife sequenziell?

$ time for x in $(seq 1 1000); do cat /dev/urandom | head -c 100000 | gzip &> /dev/null; done
real 0m31.869s
user 0m8.301s
sys 0m33.658s

Okay. Jetzt weiss ich, das GNU Parallel eher was für (rechen-)intensivere Aufgaben ist als für viele kleine Prozesse. Anscheinend braucht das Parsing des zusätzlichen Binaries doch etwas zu lange um einen Prozess zu ordnen der sowieso nach sehr kurzer Zeit wieder beendet ist. Alles in allem gefällt mir GNU Parallel aber sehr gut wenn man weiss für was man es einsetzen muss :)

Auf deren Projektseite habe ich mich dann etwas schlau gelesen und wie auch schon bei dem Megabitmeter über tinkersoup.de meine Teile bestellt. Auf der Projektseite ist die Konstruktion des ganzen finde ich zwar nicht sonderlich gut beschrieben, aber man kommt mit ein bisschen Googeln und Reverse Engineering schon weiter.

Habe dabei aber einen Arduino Nano benutzt, weil mir die Anschlüsse bzw “Architektur” besser gefällt und ich nicht erst ein Breakout Board von Seriell auf USB nachkaufen musste. Entgegen aller Erwartungen musste ich die Firmware dafür nichtmal modifizieren, da auch bei diesem Board ein ATMega328 verbaut ist.

Ich habe mir wegen der einfacheren Anbringung am Nano so eine Art Halterung/Breadboard mitbestellt, in dem ich die Adern mit Schrauben einfacher verbauen konnte.

Die Potenziometer (wieder was, das ich gelernt habe) sind in Reihe an den Ground und den 5V Pin geschlossen. Der jeweils mittlere Pin der Drehschalter kommt an die Analog Pins 0 bis 4.

Danach kam der (für mich) kniffligere Teil. Der Audio Jack (bzw. Klinke Buchse) hat von Haus aus 5 Pins. Auf der Projekte Seite von Auduino nur Input und Ground. Nach bisschen schlaulesen in Wikis und Foren scheint es, als würden die verschiedenen Revisionen von Klinke andere Features mit sich bringen. für den Mini Synthesizer hätte vollkommen Klinke Mono ausgereicht. Diverse Zusatzfunktionskanäle sind da eigentlich überflüssig aber im Audio Jack bei TinkerSoup integriert.

Nach etwas Trial and Error Verfahren den weg für Doofe gewählt. Ich hab ehrlichgesagt einfach ein altes Klinke Stecker auf Buchse Kabel aufgeschnitten und mir die Belegung auf der Steckerseite angesehen.

Bei 3poligen Klinken Steckern sind die vorderen beiden Kontakte fürs Signal (Links, Rechts) und hinten für Ground. Habe dann die beiden Signaladern auf der Buchsenseite verdrillt und wie vorgesehen in den Digitalen Pin 3 geklemmt. Ground natürlich an seine Stelle.

Im Endeffekt wars dann schon fertig. Firmware mit dem Arduino IDE auf den Chip geladen und hat auch schon funktioniert. Aber weil ich dann ständig die Potenziometer durcheinander gebracht habe, hab ich noch eine alte Plastikbox aus dem Baumarkt meiner Wahl benutzt, die entsprechenden Löcher gebohrt dort das ganze eingebaut.

Etwas smoother ;) Noch ein paar kleine Kostproben von einem wirklich unbegabten Synthesizer-Bediener. Beim hören etwas aufpassen, ab und zu ist mir da ein Ton entglitten.

Auduino Sample Mp4
Auduino Sample WAV 16 bit 22 Kkhz

Ich weiß gar nicht mehr wie genau ich auf fbcmd gekommen bin.  Im Zweifel über einen XML basierten Medienkanal. Jedenfalls ist fbcmd ein äußerst schönes Tool um die gängigen Informationen zum eigenen Facebook Account auf der Kommandozeile abzufragen. Dazu bietet es wahnsinnig trickreiche Queries und “Vergruppungen” der Facebook Bekanntschaften. Alles dazu hier und besonders hier.

Somit lässt sich wunderbar ein automatisches “Alles Gute zum Geburtstag!” bauen. Vorraussetzung ist hierfür eine funktionierende Installation von fbcmd.

Der von fbcmd vorgeschlagene Query um eine Geburstagsnachricht an die Pinnwand von jenen zu senden, deren Geburtstag sich heute jährt lautet:

fbcmd WALLPOST =bday 'Alles Gute zum Geburstag!'

Das lässt sich natürlich wunderbar in einen Cronjob verbauen, der einmal täglich um 15:00 eben diesen Query ausführt:

0 15 * * * fbcmd WALLPOST =bday 'Alles Gute zum Geburstag!' > /dev/null

Weil ich aber wissen möchte, wem mein Rechner alles in meinem Namen zum Geburtstag graturliert hab ich das noch leicht modifiziert und lasse mich via Mail darüber benachrichtigen:

0 15 * * * fbcmd WALLPOST =bday 'Alles Gute zum Geburstag!' | grep -v "^No Friends With Birthday Matches$" | mail -s "fbcmd Gratulation" user@domain.de

Eigentlich ist der Titel des Posts gar nicht richtig. Man vergisst Sie trotzdem. Aber ein Device erledigt die Arbeit für einen :)

Ich hab mir dann kurzerhand was selber gebastelt. Ich gebe zu ich hätte es auch so gestaltet können das es einfach nur für meinen Use-Case gereicht hätte, aber das erschien mir unsinnig. Wenn ich mich schon einen halben Abend hinsetze, dann können ja evtl. auch mehr Menschen was davon haben. So entstand dann die bash-progress-bar.

Zu allererst besteht der Ladebalken aus einer while true Schleife. Sollte die Bar in ein Skript einbaut werden wäre die Bedingung dem Skript anzupassen. Ob das jetzt ein test -e auf ein File ist das getouched wird oder eine Art Counter bleibt jedem selbst überlassen.

$ git clone git://github.com/noqqe/bash-progress-bar.git
$ cd /bash-progress-bar/
$ ./loading.sh
> [            #####       ]

Alle Parameter sind natürlich anpassbar. Ich habe versucht so gut wie alles anpassbar zu halten. Ich hoffe das ist mir gelungen ;)
./loading.sh Groesse Geschwindigkeit Rahmen-Anfang Füllcharacter Rahmen-Ende
./loading.sh 50 0.02 [ "######" ]
Ohne irgendwie ein GIF-File zu erstellen kann ich das jetzt leider schlecht im Blog demonstrieren. Deshalb: ausprobieren :) Mehr Infos auf der Github Page.

Fragen, Anregungen, Kritik erwünscht!

Als ich vor ca. einem Monat Taskwarrior für mich entdeckt habe, war eigentlich alles gut. Ich hab mich über den integrierten interactive Mode wirklich gefreut. Anfangs. Mit der Zeit habe ich aber festgestellt, dass mich dieses “Ding” fast in den Wahnsinn treibt. Mir persönlich fehlen einfach elementare Features wie einfaches Cursor bewegen nach vorne und zurück. Überhaupt eine History zu haben wäre schon ein enormer Vorteil.

Ich hab mir dann kurzer Hand selber eine Taskwarrior Shell Variante gebaut, die im großen und ganzen auf einer Bash basiert.

Features:

• History vorwärts und rückwärts via Pfeiltasten
• Cursorbewegung vorwärts und rückwerts in der aktuellen Zeile
• Alle Kommandos nativ benutzbar ( $ add pri:H pro:Living Miete zahlen )
• ID’s direkt nutzbar ( $ 34 edit oder $ 12 pri:H )
• separate Logging Funktion in $HOME/.better-task-shell_history
• OS Befehle weiterhin nutzbar! ( $ vim /home/user/foobar.txt )
• Automatische Erkennung von doppelten Aliases
• Automatische Alias Generierung fuer os-binaries ( $ ls  = task ls  ; os-ls = /bin/ls )
• Auto-Komplettierung aller Taskwarrior Befehle und definierte Aliase

Known Bugs:

• Neu angelegt tasks  können derzeit noch nicht via ID aufgerufen werden.
  $ add Uberweisung einwerfen
  Created Task 45
  $ 45 pri:H
  bash: 45: Kommando nicht gefunden
  Für beim Start bestehende Einträge funktioniert dies allerdings problemlos.
• Mode -v ist bis jetzt noch nicht benutzbar aber bereits implementiert.

Das ganze gibts jetzt unter http://github.com/noqqe/better-task-shell

Usage:

git clone git@github.com:noqqe/better-task-shell.git
$ cd better-task-shell
$ ./better-task-shell

Git follows Linux’s philosophy of refusing to protect you from yourself. Much like Linux, Git will sit back and watch you fuck your shit right up, and then laugh at you as you try to get your world back to a state where up is up and down is down. As far as source control goes, not a lot of people are used to this kind of free love.

Ich rezitierte also Julius Zitat. Blogpost-Inception?

Wie es begann:

Vorbereitung:

Abschluss:

Ende:

http://www.deaddrops.com/db/?page=view&id=804

Dazu gibt es ein Skript. Nämlich zre.R (Ob das die Konvention bei R-Skriptnamen ist, kann ich nicht sagen ;) )

#!/usr/bin/env Rscript

### General R-Script
# MySQL
library(RMySQL)
con <- dbConnect(MySQL(), user="", password="", host="", client.flag=CLIENT_MULTI_RESULTS)
# Style
zre_colors <- colors()[grep("green",colors())]
zre_mint <- colors()[c(48,86,50)]

Im Klartext wird aus dem CRAN Library Verzeichnis die Library RMySQL includiert und die Verbindung in der Variable con abgelegt. Ähnlich wie bei PHP. Für alle Debian / Ubuntu Benutzer empfiehlt sich aber, die Library einfach über das Paketsystem nachzuinstallieren.

$ aptitude install r-cran-rmysql

Standardmäßig sehen Graphen die mit R erstellt werden ziemlich mau aus. Die weiteren Variablen unter Style habe ich gewählt um mir die Colorierung der Graphen etwas zu erleichtern. Diese werden später einfach als Attribute in den Plots/Barplots gesetzt und ausgewertet. Ich fange einfach mal der Reihe nach an:

Die Abfolge ist immer ziemlich ähnlich. Zu aller Erst wird der Query für die Datenbank an die Variable sql übergeben. Diese Variable wiederrum wird zusammen mit der Connection an die Funktion dbGetQuery übergeben und das Ergebnis dessen schliesslich in zre_wins gespeichert. Anschliessend ein paar kleine Informationen an das Dateiformat übergeben und den Graphen bauen.

Die Funktion par lässt sich erstmal als eine Art Environment Funktion für Graphen verstehen. Hier werden Eigenschaften wie Schriftfarbe, Hintergrund, Axenfarbe, und Liniendicke definiert. Danach kommt (wie ich finde) der schwierigste Teil. Bauen des Graphen. Je nach Art des Graphen (Balken, Linien, Torte u.ä.) werden logischerweise verschiedene Parameter erwartet. Die Daten werden hierbei jetzt als Matrix an ein Balkendiagram übergeben. Weitere Informationen wie die Überschrift (main) und die Beschreibung der Balken (names.arg) werden einfach angefügt.

# Graph: Wins

sql <- paste("SELECT COUNT(id) AS sum, side FROM zombies.zre_wins GROUP BY side;")
zre_wins <- dbGetQuery(con, sql)
png(file="wins.png", width=400, height=400)
par(col="white", bg="transparent", col.axis="white", col.lab="white", col.main="white", lwd=2)
barplot(as.matrix(zre_wins$sum), main="Game Summary", names.arg=c(zre_wins$side), beside=TRUE, col=zre_mint)

Selbes Spiel wieder, nur mit mehr Balken und anderem Use-Case. Diesmal werden die 25 Konflikte mit den meisten Opfern visualisiert.

# Graph: Highest Kills

sql <- paste("SELECT id, kills FROM zombies.zre_kills ORDER BY kills DESC LIMIT 25;")
zre_matches_highest <- dbGetQuery(con,sql)
png(file="highestkills.png", width = 400, height = 400, bg="transparent")
par(col="white", bg="transparent", col.axis="white", col.lab="white", col.main="white", lwd=4)
barplot(zre_matches_highest$kills, zre_matches_highest$id, main="25 Highest Kills", beside = TRUE, ylab="Kills", col=zre_colors)

Aber da Balkendiagramme auch irgendwann Langweilig werden geht das natürlich auch anders. Die 25 letzten Konflikte werden im “Opferverlauf” wie folgt dargestellt:

# Graph: Kills

sql <- paste("SELECT kills FROM zombies.zre_kills ORDER BY id DESC limit 25;")
zre_kills <- dbGetQuery(con,sql)
yrange <- range(zre_kills$kills)
xrange <- length(zre_kills$kills)
png(file="kills.png", width=400, height=400, bg="transparent")
par(col="white", bg="transparent", col.axis="white", col.lab="white", col.main="white", lwd=4)
plot(zre_kills$kills, xlab="Games", type="b", ylab="Kills", main="Kills from last 25 Attacks", col=zre_mint)

Damit es nicht immer nur um Tote geht, auch mal was erfreuliches. Die Geburtenrate in ZRE steigt! :)

# Graph: BirthRate

sql <- paste("SELECT Month(date) AS month, count(id) AS born FROM (SELECT *, Month(date) AS M FROM zombies.zre_born) t Group by M; ")
zre_birthrate <- dbGetQuery(con,sql)
png(file="birthrate.png", width=400, height=400)
par(col="white", bg="transparent", col.axis="white", col.lab="white", col.main="white", lwd=3)
barplot(zre_birthrate$born, xlab="Month", ylab="Born Humans/Zombies", names.arg=c(zre_birthrate$month),main="BirthRate per Month", col=zre_colors)

Und auch das Wetter soll bei der ganzen Sache nicht zu kurz kommen. Hierbei bitte besonderes Augenmerk auf die Legende rechts oben. Eine direkte Zuordnung der Werte und Farben ist nicht nötig, da die Farben in der selben Reihenfolge von zre_colors befüllt werden wie die Balken. Die erschreckend hohe Zahl an Naturkatastrophen erklärt das aber trotzdem nicht :)

# Graph: Weather
sql <- paste("SELECT COUNT(id) AS count, weather FROM zombies.zre_weather GROUP BY weather ORDER BY count DESC;")
zre_weather <- dbGetQuery(con,sql)
png(file="weather.png", width=400, height=400)
par(col="white", bg="transparent", col.axis="white", col.lab="white", col.main="white", lwd=2)
barplot(zre_weather[,1], main="Weather in ZRE", beside = TRUE, col=zre_colors)
legend( 5, 40000, zre_weather$weather, cex=0.9, fill=zre_colors, col="white")

Das volle zre.R Skript befindet sich wie das meiste auf Github: https://gist.github.com/1031260

Im Moment ist es abe so, dass es keinen anderen verbreiteten Weg gibt Content bzw. Software von Privat-Menschen zu belohnen, weil er/sie mir geholfen hat. Deshalb (und auch weil mich die Oberfläche interessiert hat) habe ich mich dort angemeldet und verteile seit 2 Monaten etwas Geld hier und da. Vorwiegend an Podcasts, Taskwarrior und Blogs von Leuten die ich kenne. Ich habe initial 8 Euro überwiesen mit denen ich jetzt erstmal 4 Monate rumflattern werde. Das das nicht die Welt ist, ist mir klar.

Und da ich jetzt sowieso schon einen Account dort habe, habe ich auch meinen Flattr-Button im Blog (links) eingebunden. Es wird erstmal keinen individuell Button für einzelne Posts geben und es braucht sich auch niemand verpflichtet fühlen da drauf zu drücken.

UPDATE:
Ich hab Flattr “Things” bis eben missverstanden. Bis jetzt war im Blog der Flattr Button zu meiner Person eingebunden. Scheint aber als wäre das nicht der Use-Case. Ich habe jetzt für meinen Blog selbst noch ein “Thing” eingereicht und dieses mit der richtigen URL eingebunden. Vielen dank an die beiden die bereits den Flattr Knopf gedrückt haben! Leider ist das jetzt nicht mehr sichtbar hier.

Nach zwei Tagen herumspielen und einem wirklich hervorragendem How-To hat mir Taskwarrior allerdings so gefallen, dass ich mich entschlossen habe MyTinyTodo aufzugeben und zu Taskwarrior zu wechseln. Da ich meine TodoListe aber auch gerne als eine Art “Log” verwende musste ich die Aufgaben erst aus MyTinyTodo migrieren.

Realisiert habe ich das über ein kleines Bash-Script, welches die Daten aus der MyTinyTodo MySQL Datenbank ausliesst und daraus automatisch Taskwarrior Statements formuliert. Allerdings: Ich habe absichtlich nur abgeschlossene Tasks über die “LOG”-Funktion von Taskwarrior einfuegt.

Aus dem Datenbank Eintrag:

mysql> select d_completed,  mtt_lists.name as liste, title from mtt_todolist, mtt_lists where mtt_lists.id = mtt_todolist.list_id order by d_completed desc limit 1;
+-------------+-------+--------------+
| d_completed | liste | title        |
+-------------+-------+--------------+
|  1307714692 | Home  | Miete zahlen |
+-------------+-------+--------------+
1 row in set (0.00 sec)

formuliert das Skript beispielsweise folgendes Kommando für Taskwarrior:

task log due:20110610 pro:IMPORT-Home Miete zahlen

Das passiert eben für jede Eintrag in der Todo-Datenbank, damit ich dort nachschlagen kann wann was passiert ist.

Ich muss sagen der Inhalt war wenig bis gar nicht interessant. Allerdings muss das Bild, wie ich da mit Fahrrad, Laptop auf dem Lenker und Kabel in eine tote Mauer stehe ziemlich skurril ausgesehen haben.

“Gibts da Strom umsonst oder was ist da los?”

“Junger Mann, das is ja unerhört. Mit dem Laptop am Lenker Fahrrad fahren! Das ist eine Gefährdung für den Verkehr!”

“Ach, was wird das denn? Muss ich die Politzei verständigen?”

… um nur ein paar Zitate aufzuzählen. Zur Beruhigung aller: Ich bin natürlich nicht mit dem Fahrrad gefahren während ich den Laptop am Lenker hatte. Das (und den eigentlichen Grund meiner Anwesenheit) habe ich natürlich auch brav jedem erzählt der mich in den insgesamt nur 20 Minuten angesprochen hat. Insgesamt war das sogar witziger als der Deaddrop selbst. Werde das auf jedenfall wiederholen.

Zunächstmal hab ich mich ausgiebig mit dem HowTo beschäftigt welches ich (bis auf ein paar Stellen) sehr gut finde. Die letzten Paar Unstimmigkeiten habe ich dann mit dem wirklich netten und zuvorkommenden Betreibern des Projekts via Mail abstimmen dürfen :) Das lag aber auch an meinen fehlenden elektrotechnischen Kenntnissen.

Ich muss dazu sagen, dass ich in der glücklichen Situation war und jemanden kannte, der in einer Firma tätig ist, die solche Messgeräte anfertigt wodurch ich keinen Kit kaufen musste. Das ist auch der Grund warum das Messgerät etwas anders aussieht.

Ich denke auch das der Sinn des Projekts eher das “do-it-yourself” ist und der wirtschaftliche Erfolg nur eine positiver Nebeneffekt der Betreiber ist… (Zumindest hoffe ich, dass ich das nicht falsch interpretiert habe). Außerdem schwierig war, dass der Kit 2 (incl. dem Arduino) nicht verfügbar war, da laut Twitter gerade keine Arduinio Nano in rauen Mengen billig einzukaufen sind. Den Arduino Prozessor habe ich deswegen von TinkerSoup.de geordert.

Wenn alles fertig gebastelt ist, kann man dem Gerät einfach via echo Werte übergeben.

$ echo "200" > /dev/ttyUSB0

Ein paar Anwendungsbeispeile:

Zufällige Zahlen auf das Gerät projezieren
while true; do RND=$(($RANDOM % 99 * 10)); printf "$RND\n" > /dev/ttyUSB0 ;echo $RND; sleep 2 ; done

Zombie Kill Meter (In Verbindung zu zombies.n0q.org)
while true ; do mysql -u user -ppw -e \"SELECT kills from zombies.zre_kills ORDER BY id DESC LIMIT 1;\" | grep -v ^kills ; sleep 3; done" > /dev/ttyUSB0

Port 80 Verbindungen des Webservers
ssh user@host "while true; do echo \$(( $(netstat -tapn | grep -c -e ':80\s*') * 100 )) ; sleep 2; done" > /dev/ttyUSB0

An weiteren Snippets bastle ich im Moment noch. Werden eventuell nachgereicht wenn Sie spruchreif sind. Am Ende noch ein riesen Danke für die Software und die Projektidee sowie das wunderbare HowTo an das Team von megabitmeter.de

Bei aller verwunderung gibt es in der Datenbank keinerlei Funktion einen Toten Toten Drop zu melden. Wie es der Zufall so will gibt es aber genau seit heute(!) einen neuen DeadDrop in Erlangen: http://deaddrops.com/db/?page=view&id=682

Für meinen Use-Case scheint das allerdings nur begrenzt von Nutzen zu sein. Ich mache vielleicht etwas falsch, aber wenn ich 1000 Queries in MySQL kippe, dauert nur einen Bruchteil so lange wie in postgreSQL. Um das zu veranschaulichen:

$ time for x in $(seq 1 1000) ; do mysql -u root -ppw -e "insert into foobar.foo values ($x, now());" ; done
real 0m7.349s
user 0m0.060s
sys 0m0.380s

$ time for x in $(seq 1 1000) ; do psql --quiet -d foobar -c "insert into foobar values ($x, now());" ; done
real 1m28.363s
user 0m37.450s
sys 0m13.020s

Kann mir jemand sagen woran das liegt? Ich kann mir nur schwer vorstellen das PostgreSQL so hinterher hinkt.

Ich habe mir überlegt wie schwierig es wohl sein kann, diesen in Bash zu implementieren. Nach kurzem googlen findet man immer wieder eine kleine wirklich ausgefuchste, trickreiche Zeile:

$ tr A-Za-z N-ZA-Mn-za-m

Irgendwie war mir das aber zu langweilig, mir die Arbeit von einem vorgefertigten Binary erledigen zu lassen. Ich wollte es in echtem Bash selbst schreiben. Was ich dann auch getan habe.

Usage:

$ ./rot13 "hello world"
uryyb jbeyq

$ echo "hello world" | ./rot13
uryyb jbeyq

# Verschlüsseln und entschlüsseln hintereinander.
$ echo "hello world" | ./rot13 | ./rot13
hello world

# Zeichentabelle anzeigen
$ ./rot13 -t

Sollten Zeichen vorkommen, die sicht nicht im Table befinden, werden diese automatisch erkannt und bleiben unverschlüsselt.

$ ./rot13 "Ich wollte nur [...] und dann ist das Universum explodiert."
Ipu jbyygr ahe [...] haq qnaa vfg qnf Uavirefhz rkcybqvreg.

Genau genommen ist es sogar mehr als nur ROT13. Mit wachsendem Zeichen-Table wächst auch automatisch die Verschiebung der Stellen mit. Es ist also möglich einen eigens definierten Table mit Zeichen anzulegen und diesen zu nutzen. Einzige Bedingung: Es muss eine gerade Anzahl von Zeichen sein.

Und zum Schluss: Danke an /dev/radio für die erhebliche Verkürzung meiner Zugfahrten :)

Dokumentation

Präsentation

Zu danken habe ich dabei hauptsächlich all den wunderbaren OpenSource Tools, die mir zur Erstellung und Umsetzung gedient haben. Um einige zu nennen:

• LaTeX bzw. TeX-Live (Dokumentation)
• HTML & Slidy (Präsentation)
• git (Projektinhalt)
• etckeeper von Joey Hess (Projektinhalt)
• gitolite (Projektinhalt)
• und natürlich allen Debian Developern, die die genannte Software paketiert haben :)

Initiales Setup

Als erstes muss das Verzeichnis initial eingerichtet werden. Initialisierung, hinzufügen aller Dateien und ersten Commit erstellen.

$ cd $HOME/.minecraft
$ git init
$ git add .
$ git commit -a -m "Initialer Commit"

Spielstände manuell Laden und Verwalten (Commits)

Einer der gravierendsten Vorteile. Wer wie ich oft an Klippen hinunter stürzt oder an einem (oder auch mehreren :P ) Creeper(n) scheitert wird das bestätigen können. Einmal gefallen/gestorben gibt es kein zurück mehr. Bis jetzt.

Die hypothetische “Herausforderung” scheint sich gerade aufzutun. Ob jetzt Creeper, Berg oder sonst was ist erstmal egal. Könnte auf jeden Fall kritisch für meinen Minecraft Character enden.

$ git commit -a -m "Ob man den Sprung ueberlebt?"

Nach einem kurzen Tab in die Konsole, sollte das Spiel erstmal gesichert sein und ich kann den Sprung wagen.

Anscheinend überlebt man nicht, aber genau das war auch der kritische Punkt. Genau jetzt bin ich in der Lage meinen alten Spielstand wiederherzustellen. Mit nachfolgendem Kommando verwerfe ich alle seit dem letzten Commit entstandenen Änderungen an meinem Spielstand. Vorher dringend aufs Minecraft Titelmenü zurückkehren!

$ git stash
# Update
# oder alternativ:
$ git checkout -f

Dieses Szenario lässt sich nicht nur auf gerade geschehene Ereignisse abbilden sondern auch zwischen Commits die längere Zeit her sind. Wenn nach einer halben Stunde/einem Monat klar wird, das der Minecraft Char gerade nur Müll verzapft hat, kann auch zwischen mehrere Commits hin und her gesprungen werden. Mit welchen git Kommandos das bewerkstelligt wird, bleibt jedem selbst überlassen.

git-revert macht den letzten Commit rückgängig, erstellt dabei einen neuen in dem die Änderungen enthalten sind. Das ist in soweit gefährlich, dass zwischenliegende Commits unberührt bleiben und eventuell in einen großen Haufen Datenmüll zerfallen(!). Eher Anwendung für den “Warp” an einen früheren Zeitpunkt X findet daher git-reset.

$ git reset 66a2594
# oder
$ git reset HEAD^

Das Working Directory wird damit auf einen Stand gebracht, wie es zum Zeitpunkt des angegebenen Commits aussah. Dieser kann somit auch weiter in der Vergangenheit liegen.

Automatische Speicherung (Bash-Einzeiler)

Allerdings muss ich zugeben, dass diese Praxis relativ schnell aufwendig wird. Immer zwischen Fenstern hin und her zappen ist ja auf Dauer auch eher zermürbend. Daher habe ich mir diese “Arbeit” von einer kleinen Bash Zeile abnehmen lassen.

$ SEKUNDEN=10 ; while true ; do git add . ; git commit -a -m "AutoSave $(date)" ; sleep $SEKUNDEN ; done

Ich denke es ist Geschmacksache wie oft bzw. in welcher Frequenz die Commits abgesetzt werden können. Bis jetzt bin ich mit ca 300 Sekunden (5 Minuten) am besten Gefahren. Die Commits rieseln vor sich hin und beeinträchtigen so in keinster Weise den Spielfluss.

[master bf9dd85] AutoSave Mo 4. Jul 19:56:17 CEST 2011
4 files changed, 15 insertions(+), 12 deletions(-)
rewrite saves/0pen_Running/level.dat (100%)
rewrite saves/0pen_Running/level.dat_old (100%)
[master 5ddedc8] AutoSave Mo 4. Jul 19:56:27 CEST 2011
4 files changed, 17 insertions(+), 19 deletions(-)
rewrite saves/0pen_Running/level.dat (100%)
rewrite saves/0pen_Running/level.dat_old (100%)
[master 2d33023] AutoSave Mo 4. Jul 19:56:37 CEST 2011
4 files changed, 10 insertions(+), 11 deletions(-)
rewrite saves/0pen_Running/level.dat (100%)
rewrite saves/0pen_Running/level.dat_old (100%)


Parallele Welten (Branches)

Um einfach mal ein Anwendungsbeispiel zu nennen: Wer in seinem virtuellen Minecraft-Keller mal raue Mengen an TNT gebunkert hat, möchte es nach Möglichkeit auch mal benutzen, right? Aber danach das ganze Dorf wieder aufbauen? Nee… Branching!

Das ist der Punkt an dem die Geschichte der lokalen Minecraft Map sich in zwei Teile spaltet. In einer wird das eigene Bauwerk Sodom und Gomorra mäßig untergehen und in der anderen weiterhin existierenden Welt tollen sich Pigs und Sheeps in Minecarts herum. Die Abzweigung lässt sich wie folgt bewerkstelligen.

$ git branch blowup
$ git checkout blowup

Jetzt kann man in aller Seelen Ruhe TNT verteilen und auch mal Destroyer statt Builder spielen. Tipp: Commit vor der Sprengung setzen :P Explosion immer und immer wieder von vorne genießen ;) Bemerkenswert sind außerdem die unterschiedlichen Abläufe von ein und der selben Explosion, aber dazu vielleicht wann anders ein Blogpost. Irgendwann wird aber auch das dann zur Routine und man wechselt via

$ git checkout master

wieder zu den Schäfchen. Der Branch “blowup” bleibt aber bestehen und lässt sich auch nach weiteren Spielständen immer wieder herbeirufen. Ich habe mittlerweile eine Art Branchset meiner “Lieblingssituationen” im Game, die ich immer wieder durchspielen kann, wie es mir gerade gefällt. Und nein es sind nicht immer nur Explosionen :)

Networking, Baby! (Remotes)

Mein Minecraft Setup mit allen Einstellungen und Spielständen zentral an einem Ort zu haben war ehrlich gesagt meine erste Motivation git einzusetzen. Ich spiele Minecraft auf 3 verschiedenen Maschinen (Ubuntu, Debian und sogar Mac OSX) und wollte keine 3 unterschiedlichen Maps pflegen müssen. Deshalb fing ich an auf meinem Server zwischen zu lagern. Ein eigens laufender git-Server ist hier aber Vorraussetzung! Freies Hosting bei beispielsweise Github fällt wegen der großen Datenmengen (ca. 300MB bei mir derzeit) und der fehlenden Privatsphäre flach. Remote-Server hinterlegen und aktuellen Stand pushen:

$ git remote add origin git@gitserver.com:minecraft
$ git push origin master

Remote-Server auf anderen hosts klonen:

# Ubuntu/Debian
$ git clone git@gitserver.com:minecraft $HOME/.minecraft
# Mac OSX
$ git clone git@gitserver.com:minecraft $HOME/Library/Application\ Support/minecraft

At least

Ich möchte nicht sagen, dass dies hier der ultimative Weg zum heiligen Gral in Minecraft ist. Manchmal weckt eben diese erzeugte “Sicherheit” durch den Reset eine gewisse “Wayne…” Einstellung in einem, die dem Spielspaß ein Kleinwenig den kitzel raubt. Gerade am Anfang hat es mir aber extrem geholfen, nicht bei jedem Wipe alle Items zu verlieren oder sich nach einem Ausflug in den Wald wieder “zurück warpen” zu können.

Auf weitere Ideen im Umgang mit Minecraft und Git freue ich mich natürlich wie immer :)

Wenn Ihr mich fragt, schiesst die BitCoin Mining Gesellschaft am Ziel vorbei. Separate Rechner betreiben schiesst am Ziel vorbei. Hunderte von Euros für neue Grafikkarten ausgeben um 5 MegaHashes/s mehr rechnen zu können schiesst am Ziel vorbei. Euro’s für BitCoins bezahlen schiesst sowieso am Ziel vorbei. Man kann BitCoins meines Erachtens auch benutzen ohne Kopfstände zu machen. Immer wenn der Rechner sowieso gerade läuft, mit der Hardware die man zur Verfügung hat.

Aus diesem Grund habe ich ein kleines Skript gebastelt. Einen Start-Stop-Daemon für /etc/init.d/. Es startet automatisch wenn mein Rechner hochfährt und hört auf wenn ich Ihn herunterfahre. Ganz einfach

$ wget -O /etc/init.d/bitcoin https://gist.github.com/raw/1007794/bitcoin.sh
$ chmod +x /etc/init.d/bitcoin
$ update-rc.d bitcoin defaults

https://gist.github.com/1007794

Ich möchte aber dazu sagen, dass ich dies Funktionstüchtigkeit des Skripts nicht auf anderen Rechnern/Betriebssystemen getestet habe. Vor Benutzung also bitte lesen, verstehen ggf. anpassen. Außerdem wird ein Account bei einem Mining Pool benötigt und der Mining Client an sich (poclbm-mod). Während ich diesen Post geschrieben habe, hat mein BitCoin Mining Client entspannt auf meiner Geforce 8600 GS mit nahezu niedlichen 950 KiloHashes/s vor sich hin gemined.

Das Traurige an der Sache ist eigentlich lediglich, dass ich mir bewusst geworden bin, wie wenig Kreativität/Können ich im musikalischen Bereich vorzuweisen habe. Teilweise sind beim Herumexperimentieren zwar Interessante Ergebnisse entstanden, aber nichts wofür ich mich nicht schämen müsste ;)

$ beats song1.txt song.wav
$ open song.wav

Ich hab dann allerdings kurzer Hand begonnen, den Vorgang zu automatisieren. Erst wollte ich es outsourcen, aber dann habe ich es doch automatisiert. Da die ganze “Ich baue mir ein neues Lied”-Sache nur auf einem einzigen File beruht, dachte ich mir dass sich das mit Sicherheit auch automatisch generieren lässt.

Das Skript das dabei herauskam, taufte ich randombeats. Wie alles was ich in letzter Zeit tue habe ich es natürlich auf github veröffentlicht.

https://github.com/noqqe/randombeats

Benutzung:

Ins jeweilige Verzeichnis mit den Roh-Daten kopieren/wechseln und Skript ausführen.

$ git clone http://github.com/noqqe/randombeats
$ cp randombeats/randombeats.bash /path/to/music
$ cd /path/to/music
$ ./randombeats.bash > randomsong.txt
$ beats randomsong.txt
$ open randomsong.wav

Raus kommen allerlei sehr Interessante und manchmal auch schöne Rhythmen. Aber manchmal auch akkute Ohrenschmerzen verursachen. Ein paar davon sammle ich mittlerweile in einem separaten Branch im Git-Repo. Diesen kann ich aber nicht uploaden, weil die größe meines Github Accounts auf 300MB beschränkt ist. Aber vielleicht finde ich anderweitig Möglichkeiten die Ergebnisse zu publizieren.

Mittlerweile habe ich folgenden Befehl in einer Schleife laufen.

./randombeats.bash > rnd.txt && beats rnd.txt && open rnd.wav

An Feedback, Kritik oder Anmerkungen zu Verbesserungen an den Eckdaten des Skripts bin ich wie immer sehr interessiert :)

Update: Kurze WAV-Files generiert und als Beispiel hochgeladen.

randombeats example 1
randombeats example 2

Hintergrund
Heute ist der 3. Mai und morgen ist meine Abschlussprüfung zum Fachinformatiker. Natürlich sollte man da andere Sachen machen, als Shell Zeilen zu schreiben, aber mein Kopf fühlt sich von den letzten beiden Wochen, die ich während meines Lernurlaubs damit verbracht habe jegliches während meiner Ausbildung vermitteltes theoretisches Wissen in mich aufzusaugen, sowas von überfüllt an, dass ich während einer Lernpause kurz den Instant-Messenger meiner Wahl angeschmissen habe. Kurz darauf wollte ich wissen, wie viele Nachrichten ich wohl seit Neuinstallation schon erhalten und gesendet habe.

Funktion
Die Zeile bewirkt im Grunde nicht anderes als alle Files auszugeben, nach Zeilen zu suchen die auf das Schema passen die dem einer “Nachricht gesendet” Zeile ähneln und sortiert, zählt und sortiert diese wieder. Vorrausgesetzt die Logfiles sind durch Pidgin im HTML Format abgespeichert.

About: “Ein Byte der Shellzauberei” – Kategorie: http://noqqe.de/archives/category/shell-zauberei

At Work war “Ticket-Squashing” immer wieder ein gutes Stichwort in unserem Ticketsystem. Wir benutzen den RequestTracker von BestPractical und ich hatte mir überlegt ein kleines Skript zu basteln, welches die Anzahl der erledigten Tickets pro User aus der MySQL Datenbank ausliesst und dann im Key:Value Format an statistical übergibt. Das hat auch ganz gut funktioniert.

Resolved ticket statistic for this month (April)
---------------------------------------------------
Tracy		|##################### (22)
Amelie		|##################### (22)
Kiri		|############ (13)
Tersina		|########## (11)
Birgitta	|######### (10)
Justine		|######### (10)
Frank		|######## (9)
Betteann	|####### (8)
Cyndy		|# (2)
Kaleena		|# (2)
Kiah		|# (2)
Roxy		| (1)
Estella		| (1)
Marj		| (1)

Allerdings haben sich dann im Laufe des Tages immer mehr (ich nenne es mal statistische-) Anwendungsmöglichkeiten ergeben. Zum Beispiel die Anzahl der erstellten Tickets pro Benutzer:

Most active creators for this month (April)
---------------------------------------------------
Christel@company.com	|############ (13)
Sydelle@company.com	|########### (12)
Birgitta@company.com	|######### (10)
Ainsley@company.com	|######## (9)
Halette@company.com	|##### (6)
Martguerita@comp	|##### (6)
Tracy@company.com	|#### (5)
care@company.com	|#### (5)
fooo@company.com	|### (4)
Christyna@company.com	|## (3)
Ethel@company.com	|## (3)
[...]

Oder die Anzahl der Tickets pro Kategorie:

Queues for this month (April)
---------------------------------------------------
General		|##################### (22)
Web		|##################### (22)
Management	|#################### (21)
WebContent	|################### (20)
IT-Interal	|################ (17)
Categ		|############### (16)
Access		|############### (16)
E-Mail-Service	|############## (15)
SWAN		|########### (12)
Domain-Service	|########## (11)
Junk		|########## (11)
DSL		|## (3)
Other		|# (2)
Hotspot-Service	|# (2)
Buchhaltung	| (1)

Um nur ein paar Beispiele zu nennen. Leider waren es zu diesem Zeitpunkt noch etliche separate Skripte, was mir eigentlich nicht gefiel. Darum habe ich es in ein modular aufgebautes Statistik Umgebungstool umgewandelt. Module sind (de-)aktivierbar und lassen sich leicht in das Rahmenprogramm einfügen. Letztendlich gibt es jetzt einen ganzen Satz von Modulen der unter Github zur Verfügung steht.

git clone git://github.com/noqqe/RequestTracker-Stats.git

Sollte außer uns noch jemand RequestTracker Stats verwenden und Interesse daran haben, ist er herzlich eingeladen die Stats Umgebung zu benutzen ggf. auch Module hinzuzufügen oder zu verbessern :) Eine (ich hoffe doch) ausreichende Anleitung zur Benutzung befindet sich im README des Github Repos.

Hintergrund
Wie auch schon beim letzten mal dreht es sich wieder um die Anonymisierung der RequestTracker Datenbank für die ich zur Zeit an einem Statistik Tool arbeite. Diesmal will ich aber nicht die EmailAdressen ändern, sondern die Namen der Benutzer. Da ich diese nicht so einfach generieren lassen kann, habe ich mir aus dem Interweb eine Liste mit Namen besorgt und mit diesen Namen die eingetragenen überschrieben. Jetzt kann ich endlich den Post über das Statistik Tool schreiben und mit Beispielen versehen :)

Funktion
Das Ganze läuft wie folgt ab: Für jede ID die ich mittels Datenbank-Verbindung in die For-Schleife einbette, setze ich einen UPDATE Befehl ab, der die Tabelle “Users” und das Feld “Name” aktualisiert. Der Aktualisierungsvorgang passiert aber generisch. Das heisst ich setze den Namen des Users auf einen zufällig ausgewählten neuen Namen aus der Datei “Names”. Das habe ich mit sed -n p FILE gelöst, was sicher auch schöner geht, aber für meine Zwecke hat es ausgereicht.

About: “Ein Byte der Shellzauberei” – Kategorie: http://noqqe.de/archives/category/shell-zauberei

Funktion
Im Endeffekt ist es nur eine For-Schleife, die alle User ID’s aus der RequestTracker Datenbank (Table: Users) ausliesst und für jeden gefundenen Eintrag die EmailAdresse auf “ID@mail.com” setzt. So bleiben die Daten auswertbar, sind aber “anonym”.

About: “Ein Byte der Shellzauberei” – Kategorie: http://noqqe.de/archives/category/shell-zauberei

Mein Job als Administrator von Debian/Linux Systemen verlangt von mir oftmals Automatisierung und Shell-Scripting in mal größerem und auch kleinerem Umfang. Oft lassen sich derartige Aufgaben sehr leicht in einem Einzeiler/Oneliner auf dem Terminal lösen. Ich mag es, wenn Lösungen schnell und einfach durchzuführen sind, besonders mit Bash. Der Anspruch dieser Aufgaben variiert genauso wie deren Umfang. Die “Zauberei” im Titel der Aktion darf also wahlweise auch etwas ironisch verstanden werden.

Als mir die Idee kam, dachte ich mir ehrlich gesagt, dass ich für eine solche Reihe wahrscheinlich nicht genügend Kanonenfutter hätte. Sprich, genügend einzeilige Bash Zauberei, die ich im Kontext dieser Reihe posten könnte. Ich beschloss den Gedanken noch nicht sofort zu verwerfen und stattdessen ein paar dieser Einzeiler zu speichern und zu sehen wie viele es werden.

In den letzten Zwei Monaten waren das jetzt ca. 12 Stück die ich als “Blogwürdig” empfand. Ich denke, das reicht mir für die Kategorie.

Aufbau

Die Posts werden immer gleich aussehen und folgende Punkte enthalten:

• Code
• Hintergrund
• Funktion
• About “Shell-Zauberei”

Informationen

Kategorie URL: http://noqqe.de/archives/category/shell-zauberei

Das Commandline Tool pdftk. Wunderbar für Debian und Ubuntu paketiert.

$ sudo aptitude install pdftk

Ich muss trotzdem zugeben, dass die Syntax mir etwas ungewöhnlich erschien, aber nicht unbezwingbar ist :) Nach ein paar Blicken in die Manpage, kam ich auch da an wo ich wollte.

$ pdftk novell-cert.pdf ripe.pdf lpic-1.pdf cisco-ccna1.pdf cat output Zertifikate.pdf
  \___/ \________________________________________________/  \_/ \____________________/
    |                            |                           |             |
    |                            |                           |             \- Ausgabe an
    |                            |                           |                Zertifikate.pdf
    |                            |                           |
    |                            |                           \- Ausgabe der PDFs
    |                            |
    |                            \- Angabe aller zu kombinierenden PDFs
    |
    \- Programmaufruf

Diesbezüglich wollte ich eine kleine For-Schleife benutzen um mehrere zufällige Werte zu generieren und in statistical zu pipen.

time for x in $(seq 1 6000); do echo "$x:$RANDOM" ; done | statistical > /dev/null

Das Ergebnis war mit 6000 Datensätzen und guten 7 Minuten relativ ernüchternd. Vor kurzem hat mich dann auch noch Vain via GitHub auf die Geschwindigkeit von statistical hingewiesen. In seinem Fork, hat er alle extern spawnenden Befehle gegen Bash interne Funktionen ausgetauscht. Siehe da:

real 0m7.788s
user 0m7.610s
sys 0m0.250s

Wahnsinn oder? Durch den Austausch von awk und grep durch interne Bash Funktionen wird das ganze ernsthaft 23x mal schneller. Vielen Dank an Vain an dieser Stelle!

Relativ schnell stieß ich aber an eine Grenze. Diese hieß “Windowsize”. Ich konnte nicht ohne bedenken eine Schleife die die Value Werte zählt bauen, die dementsprechend viele Zeichen anhängt. Denn bei Zahlen >10000 wird das ziemlich unlesbar :)

 while [ $COUNTER -lt $VALUE ]; do
        ((COUNTER++))
        echo -n "$OUTPUTCHAR"
        if [ $COUNTER -ge $VALUE ]; then
            echo
        fi
    done

Ich brauchte ein Schema, welches alle Werte einließt und eine skalierbare Basis für alle Werte schafft. Ich entschied mich für eine simple Lösung.

while [ ${FACTORCOUNT} -lt $(( ${#MAXVALUE} - 2 )) ]; do
FACTOR="${FACTOR}0"
    ((FACTORCOUNT++))
done

Letztenendes kam dann folgendes Verhalten bei meinem Key:Value Statistik Script raus. Ich mags.

# Beispiel
$ statistical john:433 alice:49 linus:12 bob:231
john    |###########################################
alice   |####
linus   |#
bob     |#######################

Damit lassen sich sogar teilweise sinnvolle Sachen produzieren. Zum Beispiel die Anzahl der Commits innerhalb eines Git-Repositories. Ich habe hier als Beispiel mal bash-it aufgeführt:

for a in $(git shortlog -sn --all | cut -f2 | cut -f1 -d' '); do echo -n "$a:" ; git log $LOGOPTS --all --numstat --format="%n" --author=$a | cut -f3 | sort -iu | wc -l; done  | statistical
Mark          |##################
Robert        |#########################################################################
Florian       |##############
Jesus         |######
John          |##############
Rich          |########
Piotr         |###
Travis        |####
Fedyashev     |##
zerobearing2  |####
Andy          |###
Daniel        |####
Jeff          |##
Karl          |##
Robert        |#########################################################################
Sirupsen      |##

Sollte jemand Interesse daran hegen, das Skript auch mal auszuprobieren es befindet sich wie immer auf Github: http://github.com/noqqe/statistical

Wie aber erfasse ich solche Informationen am Besten. Ich hatte ehrlich gesagt keine große Lust, in jedes der Events einzeln eine SQL-Verbindung aufzubauen und den gewünschten Query abzusetzen. Ganz zu schweigen von der Problemfallbehandlung (MySQL nicht installiert, Modul in Config nicht aktiviert, MySQL nicht erreichbar usw.) die ich in jedem Event hätte extra behandeln müssen.

events/
├── attack.humans.event
├── attack.zombies.event
├── born.humans.event
├── born.zombies.event
├── building.humans.event
├── collecting.zombies.event
├── die.humans.event
├── die.zombies.event
├── infos.event
├── stats.humans.event
├── stats.zombies.event
├── support.humans.event
├── support.zombies.event
└── weather.event

Stattdessen entschied ich mich ein kleines Modul in Bash zu schreiben, welches eine Hand voll übergebener Daten annimmt und dann in die konfigurierte Datenbank schreibt. Hier am Beispiel des weather.event

case $nature_msg in
1) echo "A volcano explodes." ; zresql weather vulcano ;;
2) echo "An earthquake hits the city." ; zresql weather earthquake ;;
3) echo "A hurricane hits the city." ; zresql weather hurricane ;;
esac

Als erstes übergeben wird immer der gewünschte Modus, in den zresql den Datensatz einordnen soll, danach alle weiteren Informationen die der Struktur nach erforderlich sind.

# Hurricane
$ zresql weather hurricane
# Humans gewinnen einen Kampf und vernichten 643 Zombies
$ zresql kill human 643

Das zresql Modul nimmt die Informationen dann entgegen und leitet es unter den gegebenen Umständen via sqlsend an die Datenbank weiter.

[...]
weather) sqlsend "INSERT INTO zre_weather VALUES (NULL, \"$2\", CURRENT_TIMESTAMP);" ;;
kill) sqlsend "INSERT INTO zre_kills VALUES (NULL , \"$2\", \"$3\", CURRENT_TIMESTAMP);" ;;
[...]

sqlsend ist im Grunde nur eine weitere kleine Funktion die direkt über Kommandozeile den SQL Query abschickt.

sqlsend() {
mysql -e "use $sqldb; $1" --user=$sqluser --password=$sqlpw --host=$sqlhost
}

Mit dieser Lösung bin ich eigentlich relativ zufrieden. Über Verbesserungsvorschläge und Kritik freue ich mich natürlich wie immer. Das ganze Modul ist zusehen auf Github: https://github.com/noqqe/zombie-revolution-environment/blob/master/lib/sqlstats.library.bash

So lange ist das schon her.

Freitag

Freitag war relativ entspannt. Ankunft und Aufbau des Debian Standes, mexikanisches Essen und danach Treffen mit Ben und Bier auf der Opening Party in der Mensa. Die Turnmatten in der Turnhalle waren auch kuschlig :)

Samstag

• Frühstück @ Catering-Tage – Sehr leckere Sachen.
• 1. Vortrag: Storage – Aber richtig von Martin Gerhard Loschwitz. Fand ich persönlich interessant, gerade der iSCSI-DRBD-Ansatz um FibreChannel zu ersetzen gefiel mir sehr gut.
• 2. Vortrag: Provokante Thesen zur IT-Administration von Peer Heinlein Ja, Herr Heinlein. Der Autor des Buchs, welches mich durch die LPIC-1 Prüfung geführt hat sinnierte auf eher komödiantische Art über die typischen Eigenschaften der IT-Dienstleistungsbranche. Hat allerdings Spaß gemacht zuzuhören.
• Danach Pause. Erstmal durch die Stände gestöbert, die mittlerweile so gut wie vollzählig anwesend waren. Währenddessen ausgeknobelt, ob der nächste Vortrag Icinga oder Configs mit Git verwalten wird.
• 3. Vortrag: Konfigurationsdateien mit Git verwalten von Julius Plenz. Mit bash-it benutze ich ja bereits eine Lösung die für mich zur Verwaltung Teile meines /home gut funktioniert. Aber es schadet ja nie, sich andere Taktiken anzusehen und daraus zu lernen. Genau das habe ich auch erreicht. Julius hatte ein sinnvolles zwei Branches Modell, mit denen er lokale und globale Änderungen seiner Konfigurationsdateien verwaltet. Disziplin und etwas Aufwand sind dafür allerdings nötig. (http://chemnitzer.linux-tage.de/2011/vortraege/folien/782-config-management.pdf)
• Hungerbedingt verpasste ich den Vortrag über von C.  Klostermann über Professionelle IT Dokumentation – Anforderungen aus rechtlicher Sicht Mittagsbuffet schaffte aber Abhilfe.
• 4. Vortrag: Von H. Uhlig Dem Hack keine Chance: LAMP sicher betreiben: erwieß sich grade als Administrator von Shared Hosting Systemen als hilfreich und informativ.
• 5. Vortrag: A. Scherbaum: Datenbanken von MySQL zu PostgreSQL portieren: Hierzu muss ich sagen, dass ich mir den Ansatz etwas Administrativer vorgestellt habe. Die Feinheiten der Möglichkeiten fernab vom SQL Standart von MySQL und PostgreSQL wurden aber schön ausgeführt und beschrieben. Persönlich aber muss ich gestehen, nicht sagen zu können ob PostgreSQL (abgesehen von dieser Oracle Sache) besser ist als MySQL. Es scheint eben anders zu sein.
• 6. Vortrag: P. Heinlein: SPF, DKIM und Greylisting – Was bringen Absender-Authentifizierung und der neue Spam-Schutz? : Nochmal Herr Heinlein, diesmal über SPF und DKIM als Spam-Schutz sinnierend. Aufklärend auf jedenfall, da ich die beiden Funktionen garnicht kannte und gegen Ende noch 2-12 Worte über Greylisting. Alles in Allem Runde Sache
• 7. Vortrag: T. Winde: Mit dem Midnight Commander Freiheit leben: Hauptsächlich hat mich Jan’s Vorliebe für MC in diesen Vortrag getrieben. Es war schön zu sehen, nicht nur Vorträgen von Business-Guys auf den Linux Tagen zu sehen. Ein fast schon “goldiger” Vortrag eines älteren Taxi-Unternehmers, der mir trotz geringem Lernerfolg irgendwie gefiel.
• Social Event: Wunderbares Buffet mit reichlich zu trinken und zu Essen. Hat im Endeffekt genau dem gedient, für was es gut war. Bier, Essen & Social’n.

Sonntag

• 8. Vortrag: Sonntag begann nach einer  weiteren Turnhallen-Nacht mit einem Vortrag von S. Kemter: Höher, Schneller, Weiter – openSUSE 11.4 : Der auch als Buergermeister von Karl-Tux-Stadt.de bekannte Redner, gab sich größte Mühe im Einsteigerforum das neue openSUSE, sowie die LTS, stable und unstable Linien vorzustellen.
• 9. Vortrag: Von Andreas Tille Ein Jahr OpenStreetMap: Im Einsteigerforum ging es dann für mich auch gleich weiter mit einem (für mich komplett unbekannten) Thema. OpenStreetMap und seine Anwendung. Andreas, der selbst erst ca. 1 Jahr mit OpenStreetMap arbeitet, klärte die Zuhörer über all das auf, was er gerne von Anfang an über das Projekt gewusst hätte. War sehr schön gemacht und hat mir super gefallen. Dem ansonsten überfüllten Raum scheinbar auch.
• 10. Vortrag: H. Voß Erstellung großer und größter Dokumente mit dem Satzsystem TeX: Ich muss sagen das meine Definition von “große Dokumente” ca. 1000 Seiten vor dem begonnen hatte die der Redner als große Dokumente definierte. Wenn so ein LaTeX Dokument mal länger läuft, als ein Kaffee hält, ist es eben viel :)
• Mittags ließ ich mich dann von Julius (vom Git-Vortrag) nochmal einen Schritt in Zsh einführen, da sich am Social-Event rausgestellt hat, das er der Autor von Zsh beim OpenPress Verlag ist. Gab ehrlichgesagt vieles, bei dem ich nicht schlecht geschaut hab. … Wenn ich noch Zeit fände mir das alles einzuprägen… :)
• 11. Vortrag: J. Kubieziel: Tor Bridges — Eine Brücke für freie Information: Danach ließ ich mich dann über die Risiken und Nebenwirkungen von Tor-Bridges aufklären. War sehr aufschlussreich. Langfristiges Interesse == unvermeidbar ;)
• Stand abbauen – Ab nach Hause ;)

Im großen und ganzen war es wirklich sehr schön und interessant, viele Leute und Projekte näher kennenzulernen. Die Zahl der Projekte die mich interessieren ist wiedermal gewachsen, die Zahl für die ich die Energie/Zeit habe mich auseinanderzusetzen bleibt aber leider wie immer gleich.

Und gerade als ich mich daran gewöhnt habe, dass am Rednerpult intelligente Leute stehen die Ahnung haben von dem was Sie tun, muss ich wieder in die Schule. Bäm Montag.

ZRE als Daemon (ja, der Teil kommt auch noch) hat die Eigenschaft im zufällig wiederkehrendem Rhythmus Output in ein Textfile zu produzieren. Dieses Textfile (game.txt) hat einen Platz im DocumentRoot des Webauftritts zombies.n0q.org (Ist das eigentilch das erste Mal, dass ich die URL erwähne? Ich glaube ja.). Diese möchte ich parsen und über asynchrone Aktualisierung in den Browser des Heimanwenders bringen.

Zuerst musste ich also den PHP Parser Teil schreiben, der mir die letzten 20 Zeilen, oder falls weniger eben diese aus meiner game.txt ausließt.

$input = file($zreoutput);
$resultArray = "";
$index = 20;
if (count($input) < 20)
{
   $index = count($input);
}
for($i=count($input)-$index; $i
{
   $resultArray .= $input[$i]."<br/>";
}
return $resultArray;

Als nächstes war es dann noch nötig diesen zurecht gebogenen Output dann noch selbst aktualisierend in meine Index Datei zu portieren. Dazu ist dann eine JavaScript nötig um die Funktion zu definieren.

setInterval(
    function() {
      $('#gamebox').load('../statics/gamequery.php');
      }, 2000
);

Jetzt mussten sowohl jQuery als auch das JavaScript Snippet in die Index Datei eingebunden werden. Über Kritik und Anregung freue ich mich natürlich wie immer.

<!-- game informations -->
<script src="js/jquery-min.js" type="text/javascript"></script>
<script src="js/gamebox.js" type="text/javascript"></script>
<!-- game results -->
<div id="gamebox"></div>

An der Stelle hatte ich gleich mal tatkräftige Hilfe eines Arbeitskollegen ;) Danke an dieser Stelle.

Ja -.- Ich weiss, ich hab Google Docs benutzt. Soweit jedenfalls zur Planung.

Vor ca. 2 Wochen bekamen wir @ School einen Flyer für den JOY-Dortmund Wettbewerb für Informatik Projekte von IT Auszubildenden. Was unter anderem zu dem hier erwähnten Projekt führte. Holger und ich kamen auf die Idee im Grunde ZRE für das Web umzusetzen. Aber nicht nur um die Welt auf unterhaltende Art und Weise anzeigen zu lassen, sondern viel mehr eine Analyse des Spielverlaufs mit Hilfe von Statistiken zu erstellen.

Da das “Spiel” ausschließlich aus zufällig generierten Umständen besteht, wäre die Auswertung der Entwicklungen der simulierten Welt evtl. interessant. Grade wenn man so auf Statistiken steht. :/

Anforderungen

• ZRE (in Bash geschrieben) als lauffähigen Daemon umsetzen der Output an eine Stelle generiert. (Bash – Shell)
• Eine geeignete Website erstellen bzw. designen (HTML, CSS, PHP)
• Eine Schnittstelle die die generierten “Welten” im Web anzeigt. Am besten als selbst aktualisierende live Anwendung. (JavaScript, AJAX)
• Ein SQL-Modul für ZRE entwickeln, welches statistische Werte an eine Datenbank übermittelt. (MySQL)
• PHP-Funktionen definieren, die Ergebnisse aus Datenbank abholen. (PHP)
• Statistiken visualisieren (R statistical Programming Language)

Im wesentlichen sieht die Aufgabenteilung vor, das sich Holger um Website, Design und PHP kümmert und ich mich um die Bash-Module, ZRE an sich, SQL Datenbank und statistische Auswertung bemühe. Selbstverständlich würden wir auch jegliche andere Hilfe oder freiwillige Mitarbeiter dafür begrüßen, falls Interesse besteht. Das wir an dem Wettbewerb teilnehmen wird zusehens unwahrscheinlicher, da das Projekt an sich schon eher einen Unterhaltungswert, statt dem wirklichen Nutzen eines IT-Projekt hat.

Wer sich ZRE an sich mal ansehen will, kann einfach mal das Git-Repo auschecken und starten (auch unter Mac OS X lauffähig).

$ git clone git://github.com/noqqe/zombie-revolution-environment.git
$ cd zombie-revolution-environment
$ ./zre.bash

$ aptitude install libapache2-mod-auth-pam

$ vim /etc/apache2/sites-availabe/ftp.domain.com
<Location /dir>
AuthType Basic
AuthName "FTP-Auth"
AuthPAM_Enabled On
AuthBasicAuthoritative Off
Require user FTPUSER
</Location>

Sehr wichtig an dieser Stelle AuthBasicAuthoritative Off . Ansonsten Internal Server Error. Die Schnittstelle mit der sich Apache2 gegen PAM anmeldet, wird automatisch definiert.

# cat /etc/pam.d/apache2
@include common-auth
@include common-account

Nunja, auch wenn eigentlich soweit alles klar sein sollte, schmeisst Apache2 einen Internal Server Error.

Mar 1 12:37:59 host unix_chkpwd[2682]: password check failed for user (FTPUSER)
Mar 1 12:37:59 host apache2: pam_unix(apache2:auth): authentication failure; logname= uid=xx euid=xx tty= ruser= rhost=123.123.123.123 user=FTPUSER

Was an den fehlenden LeseRechten des Users “www-data” liegt. Fügt man diesen der Gruppe shadow hinzu, funktioniert die Authentifizierung einwandfrei.

$ vi /etc/group
shadow:x:42:www-data

Zusätzliche Hilfe:
http://pam.sourceforge.net/mod_auth_pam/configure.html
http://biblio.l0t3k.net/howto/en/user-authentication-howto/x302.html

PHP5 Charset
$ vim /etc/php5/apache2/conf.d/charset.ini
[PHP]
default_charset = "utf-8"
[mbstring]
mbstring.language = utf-8
mbstring.internal_encoding = utf-8
mbstring.http_input = utf-8
mbstring.http_output = utf-8

MySQL Charset
$ vim /etc/mysql/conf.d/character
[client]
default-character-set = utf8
[mysqld]
default-character-set = utf8
character-set-server = utf8
collation-server= utf8_general_ci
init_connect = ‘SET collation_connection = utf8_general_ci’
init_connect = ‘SET NAMES utf8′
[mysqldump]
default-character-set = utf8
[mysqlimport]
default-character-set = utf8
[mysql]
default-character-set = utf8

Debian WordPress Config
$ vim /etc/wordpress/config-blog.url.php
define('DB_CHARSET', 'utf8');
define('DB_COLLATE', '');
define('WPLANG', 'de_DE.UTF-8');

Debian Locales
$ dpkg-reconfigure locales

Sollte ich es mal wieder brauchen, les ich hier nach.

Allem vorran die !Bang Suche, die ich mit der Zeit sehr zu schätzen gelernt habe. Jede große Site hat ein Kürzel, mit der Sie durchsucht werden kann. Zum Beispiel “!wiki Alan Turing“. Außerdem geben Sie an, die Suchanfragen nicht zu loggen (http://donttrack.us/), Shortcuts, sowas wie eine Syntax und Wolfram Alpha implementiert zu haben. Alles was DuckDuckGo zu bieten hat unter: http://duckduckgo.com/goodies.html

Um jetzt zum Punkt zu kommen: Meine Standardsuchleiste habe ich via Plugin schon auf Duckduckgo umgestellt. Ich habe aber die blöde Angewohnheit meine Suchanfrage einfach direkt in die Suchleiste des Firefox zu schreiben. Bisher wurde mir das immer brav von Google beantwortet. Ich dachte mit der Installation des Plugins von DuckDuckGo wäre das auch umgestellt. Dem ist aber nicht so. Leider.

Stattdessen gilt es, noch folgende Anpassungen zu machen:

• about:config in die Adresszeile tippen
• Nach dem Begriff “keyword.URL” suchen
• Das Feld doppelklicken (standardmäßig dürfte es leer sein)
• “http://duckduckgo.com/?q=” als String einfügen

Anschließend Firefox Neustart. Nein ich habe kein Geld für diesen Post bekommen. Schon wieder nicht.

Persönlich habe ich (in der kurzen Zeit, seitdem ich es benutze und kenne) R als eine Sprache kennengelernt, die nur begrenzt für coole Sachen benutzt wird. Kann an meiner Deklaration von “cool” liegen oder das sich die coolen Sachen bisher meiner Kenntnis entzogen. Aber mal davon abgesehen dass Statistiken immer interessant sind, wird R anscheinend meistens von irgendwelchen Sales-Druiden oder Marketing-Dudes verwendet, die Daten aus der DB ihres Online-Shops kratzen lassen um festzustellen wie viele Rosa Einhörner letzten Monat verkauft worden sind.

Nunja, sagen wirs so. Ich hab überlegt für was ich R nutzen würde und etwas damit gespielt. Prinzipiell ist die vorgehensweise sehr einfach. Ich hab irgendwo ein LogFile o.ä. rumliegen (sozusagen die Rohdaten) und bringe diese mit ein bisschen Bash/Shell Zauber in ein Format welches ich R vorschmeissen kann. R unterstützt… naja so ziemlich alles, was einen halbwegs anständigen Delimiter vorweisen kann.

R arbeitet in diesem Fall mit einer Interaktiven Shell, die die Eingaben interpretiert.
( $: Bash Shell. >: R Shell)

Tweetstatistik meiner Timeline analysieren (via twidge)

# Letzte 200 Tweets ausgeben
$ twidge lsrecent --all > tweets
# Usernamen sortieren und Tweets zählen
$ grep '^<' tweets | awk '{print $1}' | sort | uniq -c | sort -rn
# In R Shell wechseln
$ R
# Twitter Timeline einlesen
> twittertimeline <- read.table("twitter/tweets", head=T, sep="" )
# Kuchenansicht erstellen
> pie(twittertimeline$Tweets, label=twittertimeline$User)

An dieser Stelle kann es passieren, dass es bei zu vielen Daten wirklich sehr unübersichtlich wird. Was genau ich da falsch mache ist mir allerdings etwas schleierhaft. An der Skalierung lässt sich sicher noch arbeiten. Aber mit einem kleineren Satz von Daten, sieht es schon besser aus.
# 20 meisten Twitterer heraussuchen
$ grep '^<' tweets | awk '{print $1}' | sort | uniq -c | sort -n | tail -20 > tweets-20
# Einlesen
> twittertimeline20 <- read.table("twitter/tweets-20", head=T, sep="")
# Balkendiagram erstellen
> barplot(as.matrix(twittertimeline20$Tweets), main="Timeline", ylab="Tweets", xlab="Users", beside=TRUE, col=rainbow(20))
Und damit das ganze auch was aussagt, kann man sogar eine kleine Legende anfügen.

> legend( 1, 60,twittertimeline20$User, cex=0.6, fill=rainbow(20))

History der Bash visualisieren
Wer auf Kuchen steht, kann auch eifnach mal seine Bash History einlesen.
# Command sortieren und zählen
$ history | awk '{print $4}' | sort | uniq -c | sort -rn | head > sys/history
Used Command
1106 ls
889 vim
490 cd
423 git
116 screen
116 rm
81 ./tismc.bash
76 ps
75 less
72 ./coming-home.bash
# Das generierte File in R einlesen
> history <- read.table("sys/history", head=T, sep="")
# Aus dem Object history ein neues Object für Labels erstellen
# in denen die prozentualen Werte der Commands stehen
> history_labels <- paste(history$Command , " " , round(history$Used/sum(history$Used) * 100, 1) , "%", sep="")
# Object und Labels zu einem Kuchendiagramm formen
> pie(history$Used, main="Commands", label=history_labels, cex=0.8)
 

Mailadressen aus mail.log
Um noch ein 3. mal den Anwendungsbereich zu wechseln, kann man damit auch wunderbar das mail.log seines Mailservers unter die Lupe nehmen.

> mailaddresses <- read.table("mail/mail_addresses", head=T, sep="")
> pie(mailaddresses$Mails, main="Mail Adressen", col=rainbow(length(mailaddresses$Address) ), label=mailaddresses$Address)

Egal, mein BWL Lehrer sagte immer: Traue nie einer Statistik, die du nicht selbst gefälscht hast.

Von oben nach unten:

• Bretter der Wandverkleidung
• Regular Expressions Cheatsheet by addedbytes.com
• Git Cheat Sheet by pastejean oder hier
• Eine uralte rote Schreibtisch Lampe die ich am Dachboden meiner Eltern fand.
• Eine 25 Euro Ikea Tischplatte die mit hoher Wahrscheinlichkeit einen skandinavischen Namen trägt.
• Ein StarWars Stormtrooper den ich mal geschenkt bekam.
• Camel Active Bali Geldbörse
• Macbook 2006 Late, gebraucht von einem Kollegen bekommen.
• Ein 5-Euro 1GB USB-Stick aus dem Hause No-Name
• Zen Vision:M MP3Player (30GB)
• Leatherman Skeletool CX
• Philips In-Ear Surround Kopfhörer mit Case
• Cherry Life nano Maus

Bei Deskshots vorher aufräumen ist ja langweilig. Dieser Post darf (nach belieben) auch als Blogstöckchen verstanden werden.

Allerdings hab ich keine 50$ auf der hohen Kante um dir TextMate zu kaufen. Aber es geht ja auch anders. Was früher Smultron hieß und mittlerweile vom eigentlichen Entwickler eingestellt wurde, gibt es heute als Fork unter dem Namen Fraise.

Fraise ist OpenSource und eigentlich ein schöner schmaler Editor für Mac OS X. Meine vermisste Funktion des Apfel+R lässt sich auch hier “nachbilden”. Mit Apfel+B werden alle Kommandos angezeigt die mit Apfel+R verfügbar sind. Standardmäßig gibt es dort auch einen Satz von Dummies und sonstigem Nützlichem.

Neue Collection namens LaTeX angelegt und das Command-Set “Build LaTeX” eingerichtet. Alles weitere ist im Endeffekt nur ein Shell-Skript, welches das PDF erstellt, die überflüssigen Dateien aufräumt und das generierte pdf mittels “open” öffnet.

Extrem hilfreich und billiger als TextMate. Das Skript habe ich bei github gepasted.

Vor ein paar Tagen hab ich wieder an Club-Mate gedacht und die Suchmaschine meiner Wahl angeschmissen. Über die Homepage fand ich dann auch den nächstbesten in Frage kommenden Getränkemarkt (Keils in Bayreuth). Anscheinend ist Club-Mate auch ein in Hackerkreisen beliebteres Kultgetränk.

Wie dem auch sei, nun sitz ich hier, mit meinem ersten eigens erstandenen Kasten Club-Mate.

Nebenbei kann ich auch jedem den Hackerspace in Nürnberg K4CG ans Herz legen. Sehr nette und freundliche Hacker oder anderweitig Technik-Interessierte die auch Neulinge gut aufnehmen und betreuen ;)

buf () { filename=$1; filetime=$(date +%Y%m%d_%H%M%S); cp ${filename} ${filename}_${filetime}; }

Man spielt an der main.cf des Postfix herum oder bastelt an der xorg.conf. Und wie man das eben von dem erfahrenen Linux-Benutzer seines Vertrauens (oder dem UbuntuUsersWiki) gelernt hat, sichert man vorher die Konfigurationsdatei mit dem obligatorischen:

cp xorg.conf xorg.conf.bak

Je nach Intensität der Anpassungen häufen sich auch Backupfiles a la “xorg.conf.bak.bak” oder “.bak2 bis .bak5000″

Fügt man die obige Funktion in seine .bashrc hinzu, erledigt sich das Thema relativ schnell.

buf xorg.conf

Erstellt automatisch ein File mit dem aktuellen Zeitstempel im aktuellen Verzeichnis. Nochmal im formatierten Zustand:

buf () {
filename=$1
filetime=$(date +%Y%m%d_%H%M%S)
cp ${filename} ${filename}_${filetime}
}

Dass commandlinefu.com eine großartige Site ist, ist wahrscheinlich für die meisten nichts Neues. Teileweise regnet es dort wunderschöne kleine Kommandozeilen für den Alltag.

Es war Dienstag und ich war auf der Suche nach einem kleinen Tool oder einer Idee, wie ich am Besten kleine einzeilige “Hacks”, gebastelte Regular Expressions, MicroNotizen, ToDo’s, Logfile Schnippsel oder sonstige Informationen in Textform speichern und aufheben kann. Nachdem ich nichts fand fing ich an mir selber so ein kleines Tool zu schreiben. Als Plugin für bash-it.

Funktionen

Idee ist einfach. Alles wird in einem zentralen Ordner abgespeichert und dieser wird mit tollen Features durch hcht befüllt.

Editor
Die Basis sozusagen. Eine Notiz oder ein Kommando per Hand einfügen
$ hcht das-ist-eine-Notiz.hch

List-Funktion
Anzeigen aller abgespeicherten Files
$ hcht

Einzeilige Notiz
Den ganzen Spaß gibts auch einzeilig.
$ hcht Hallo, das ist eine kleine Notiz

Pipeable
Natürlich hat mein Lesen von Stdin Post auch einen Sinn gehabt.
$ cat mail.log | hcht maillog

Wiederholbar
Die bashinterne Funktion ist zum Beispiel auch hilfreich. Angenommen man hat grade einen total coolen Hack gebastelt und will diesen aufheben:
$ find . -iname '*.png' -exec echo '<br><img src="{}">' \; > gallery.html
$ hcht !!

Für mehr und vor allem genauere Beschreibung siehe den Source und das Readme auf github:

Dabei heraus kam: https://github.com/revans/bash-it/blob/master/plugins/hcht.plugin.bash

$ cat any_file.txt | script.sh

abbilden. Lesen von File Descriptor 0. Also Standard-Input. Mich beschäftigte das Thema aber länger, als ich es erwartet hatte. Auf Sinn und Unsinn des Skripts möchte zumindest in diesem Blogpost nicht weiter eingehen ;)

Versuche

Nach kurzem bemühen einer Suchmaschine fand ich heraus, dass /dev/stdin das magische Schlüsselwort der Sache ist. Wie also von Standard Input lesen?

cat /dev/stdin
cat /dev/stdin > /tmp/foobar

War in etwa mein erster Ansatz. Mich wunderte extrem, dass der übergebene Inhalt zwar ausgegeben wird, aber nicht in dem File steht. Erkenntnis daraus: File Descriptor 0 lässt sich anscheinend nur einmal auslesen. Zweiter Versuch:

INPUT=$(cat /dev/stdin)

Schliesslich wollte ich den Input auch im Script weiter verarbeiten. Erwies sich aber auch als ungünstig, da Zeilenumbrüche in Variablen irgendwie verschluckt werden.

Lösung

Anstatt hier weiterhin mit erfolglosen Lösungsansätzen herum zu schmeissen:
cat < /dev/stdin >> /tmp/foobar

Sieht unlogisch aus, funktioniert aber besser als alle Anderen.

/dev/stdin und read

Ich habe es nicht geschafft, nach dem einlesen von /dev/stdin eine bedienbare

read irgendeinevariable

Operation durchzuführen. Alle Eingaben werden automatisch mit dem Inhalt von /dev/stdin gefüllt. Ich konnte dafür leider noch keine Lösung finden.

Git-Repositories sind in Redmine nur über Working Copies einzulesen. Der gute Stil (und gitolite) stellt serverseitige Git-Repositories als Bare Repos dar. Bare Repos sind im Grunde nur das, was das .git/ Verzeichnis in jeder Working Copy darstellt. Es befinden sich also keine Klartext Files darin.

Creative Commons by Impact Tarmac

Diese Bare Repos lassen sich in Redmine aber nicht hinzufügen. Ob es einfach technisch nicht machbar ist, oder eine Macke seitens Redmine kann ich nicht ausmachen. Fakt ist allerdings, dass ich momentan dazu gezwungen bin Working-Copies für Redmine vorzuhalten.

Ein bisschen Dokumentation zu lesen hat mich da schon um einiges weiter gebracht. Es gibt unter der Redmine Community anscheinend zwei verbreitete Lösungsansätze.

• Cronjob der alle heilige Zeit auf Änderungen prüft
• Hook in Bare Repos einfügen, welcher auslöst wenn gepushte Änderungen vorliegen

Kurz: Ich entschied mir für die zweite Lösung. Um Ressourcen zu sparen. Oder weniger Cronjobs laufen zu haben. Erschien mir effizienter.

Hook für Bare Repo

In Hook-verzeichnis wechseln. Beispielsweise: /home/git/repositories/repo1.git/hooks/. Richtigen Hook auswählen. post-recieve führt Skripte aus, welche _nach_ dem erhalt von Commits ausgeführt werden.  Das Skript sieht vor, das ServerRepo an einen zentralen Sammelpunkt auszuchecken, Rechte anzupassen und für Redmine schreibbar zu machen.

Werden jetzt neue Commits gepushed, wird automatisch ein neues Repo gecloned und die Änderungen sind sofort in Redmine ersichtlich.

n0qorg theme

Schema: host directory (git-status dirty)>
Bis jetzt noch nicht gemerged. Denke aber das kommt noch. Theme @ Github

git_info Funktion

Gibt Übersicht über das aktuelle Repo. Ab jetzt im Framework vorhanden.

Unsinn

Dort gibt es viele Projekte die mich interessieren, ich ihnen aber trotzdem nicht folgen kann. Dazu gehören unter anderem:

diaspora/diaspora
gothfox/Tiny-Tiny-RSS
github/gitignore

Das ist so weil diese Repo’s _so viel_ Aktivität aufweisen, dass ich von keinem anderen meiner Projekte (auch nicht meiner eigenen) Meldungen mehr mitbekomme. Ich meine, wieso kann ich nicht regulieren? Wieso lassen sich Aktivitäten pro Projekt nicht zusammenfassen? Jeder Pull Request, Kommentar oder Issue wird mir direkt in meine TimeLine gepushed. Und das bei Diaspora, bei dem am Tag alleine >30 Commits passieren? Warum habe ich nicht die Möglichkeit mir nur die Aktivitäten meiner Repos anzeigen zu lassen? Denke die Jungs von Github müssen erst noch lernen solche hyperaktiven anständig mit der Plattform zu handlen. Sollte jemand die nötigen Links für mich haben, bitte immer her damit.

Sinn

Andererseits nehme ich auch an ein paar wirklich schönen Sachen teil. Unter anderem bash-it. Das Framework ist etwas, wo ich mir nichtmehr vorstellen kann vorher ohne ausgekommen zu sein.

revans/bash-it
jgoerzen/twidge

Zombies

Was ich außerdem verblüffend finde ist, dass wirklich jemand eines meiner eigenen Projekte interessant fand. Nämlich genau das, dass ich für den größten Quatsch halte. TaurusOlson hat auf Anhieb ein einwandfreies Modul und eine neue Lib für das zombie-revolution-environment geschrieben. O_o

yay. Auch wenn ich keine Ahnung von JavaScript habe.

Selbst anschauen:

$ telnet towel.blinkenlights.nl

Mir gefiel zwar nicht wirklich auf Anhieb ein ausgeliefertes Theme, aber es war relativ einfach ein Neues zu erstellen. Es war dann gelb, weil sich das schön vom Rest meines Terminals abhob. In einem Anflug wahnsinniger Einfallslosigkeit, nannte ich es dann einfach zitron. Zitron sieht folgendermaßen aus:

Das Theme reagiert (als Teil von bash-it) auf git Repos. Wenn man sich in einem versioniertem Verzeichnis befindet, wird im Prompt automatisch der Name des Branch (master) eingefügt und zusätzlich dazu überprüft, ob das Working-Directory “dirty” ist (also uncommittete Änderungen). Falls ja wird ein gelbes Asterisk eingefügt (*).

Mein Fork auf github von bash-it: http://github.com/noqqe/bash-it
Das Theme als Quelltext: http://github.com/noqqe/bash-it/blob/master/themes/zitron/zitron.theme.bash

#!/bin/bash
_DEBUG=true
if [ "$_DEBUG" == "true" ]; then echo "some debug informations" ; fi

Auch schön fand ich den eingebauten Debugmodus der Shell:

$ sh -x script.sh

Aber auch sehr umfangreiche Tools wie log4sh sind vorhanden. Ganz zu Schweigen von wahllosen “echo’s” die über das ganze Skript verteilt sind. Irgendwie gefiel mir aber keine der Möglichkeiten so wirklich. Der Code wird unlesbar, die Ausgabe ist zu kryptisch oder der Lernaufwand ist jenseits von Gut und Böse. Deshalb habe ich mich hingesetzt und überlegt, wie ich eine Debugging-Engine gerne hätte. Wie müsste sowas aussehen, damit ich es verwenden würde?

• Code sollte nicht verunstaltet werden.
• Debug Informationen sollten gut leserlich ausgegeben werden.
• Debug Nachrichten sollten sich leicht zu erzeugen sein.
• Sollte sehr einfach abschaltbar und skalierbar sein.
• Minimaler Umfang des Gesamtsystems

Nunja, im typischen Sonntag Nachmittag Größenwahn hab ich mich bemüht meine Anforderungen an den Bash Debugger umzusetzen. Ob es mir gelungen ist lasse ich jetzt mal dahingestellt, denn das ist mit Sicherheit Ansichtssache. Aber das aus dem Bedarf heraus entstandene minimal-bash-debug hat mich dann doch einigermaßen zufrieden gestellt.

Download

$ cd path/to/your/bashscript
$ wget http://github.com/noqqe/minimal-bash-debug/raw/master/.minimal-bash-debug
$ chmod +x .minimal-bash-debug

Implementation

Das runtergeladene (wirklich sehr schmale) Script dient jetzt als Auswerter für die Debug Informationen. In das Bash Script, welches es zu debuggen gilt, muss nun folgende Funktion eingefügt werden. Mein Ziel Dabei war es den Snippet der Implementierung so klein wie nur irgendwie möglich zu halten, um das Skript nicht zu verunstalten.

debug() {
  debug=2 # set debug level 0|1|2|3
  if [ -x .minimal-bash-debug ]; then
  ./.minimal-bash-debug $debug $1 $2 "$3"
  fi
}

Usage

Die Implementation der Funktion debug() in das eigene Skript hat mehrere Vorteile. Aber zuerst zur Benutzung.

debug 2 syslog "Variable VAR is $VAR"
debug 3 echo "Variable FOO is $FOO"

Das ganze ist simpel.

• debug aufrufen (debug)
• debug level bestimmen (2)
• debug mode auswählen (echo|syslog)
• debug message übergeben (Variable FOO is $FOO)

Das war auch schon der ganze Zauber. Das schöne daran ist, ist das .minimal-bash-debug Script einmal nicht mehr vorhanden/nicht ausführbar oder das debug level einfach auf 0 gesetzt, verfallen alle debug Zeilen in sofortiges Stillschweigen.

Der kurze Auszug der Erklärung ist natürlich relativ wenig. Deswegen gibt es auf Github http://github.com/noqqe/minimal-bash-debug/ ein Beispiel der Benutzung und ein README.

example.sh: http://github.com/noqqe/minimal-bash-debug/raw/master/example.sh

In den meisten Durchläufen des ZRE beendet es ganz von alleine die Simulation, weil entweder keine Humans oder Zombies mehr am Leben sind. Auf Letzteres trifft das natürlich immer irgendwie zu. Aber das ignoriere ich jetzt einfach mal. Wenn eine der beiden Seiten als Sieger hervor geht eben.

In wenigen Fällen® kommt es allerdings vor, das beide Seiten gleichmäßig stark an Mitgliedern gewinnen. Und zwar mehr als 150.000 ca. Die Chance diesen Case zu treffen würde ich jetzt auf 1:50 schätzen. Habe ihn heute 3 mal getroffen. Wie oft habe ich wohl ca. gespielt? Traurig.

Wenn dieser Case eintritt, nimmt die Simulation einen etwas schrägen Verlauf.

• Wachsende Bevölkerung: Die Anzahl der Mitglieder einer Seite wird mit
  local size=$(($RANDOM % $humans + 1))
humans=$(($humans + $size))
  berechnet.
• Maximale Opfer eines Angriffs: Die Anzahl der $victims ermittelt ZRE folgendermaßen:
  defenders=$(($RANDOM % $zombies +1))
victims=$(($RANDOM % $defenders + 1))
zombies=$(($zombies - $victims))

Die Problemstellung beläuft sich eigentlich auf $RANDOM. $RANDOM erzeugt einen “zufälligen” Integerwert von 0 bis 32767.

Die Erzeugung der Unterstützung addiert sich immer wieder sofort auf den Wert der jeweiligen Rasse. Die Anzahl der Opfer allerdings errechnet sich aus einem Teil der Verteidiger, welcher wiederrum nur ein Teil der gesamten Rasse darstellt.

Klartext: Die Wahrscheinlichkeit, dass (max.) 32767 Mitglieder Opfer werden ist wesentlich geringer als die Wahrscheinlichkeit 32767 Mitglieder Support zu bekommen. Das führt zu unverhältnismäßig großem Wachstum im Environment.

Nach einiger Überlegung habe ich beschlossen die Werte der Kämpfe nicht anzupassen und stattdessen etwas anderes Einzuführen.

Naturkatastrophen. Diese sollen automatisch bei Überschreitung eines Limits (300.000 Einwohner) oder einfach nur sporadisch etwas aufräumen. Vulkan, Hurricane oder Erdbeben. Alles dabei. Wer genau, wieviele und warum bei diesem Event ums Leben kommen entscheidet wie immer $RANDOM.

Wie dem auch sei. Vor kurzem saß ich nachts vor meiner Shell und suchte irgendeine Ablenkung. Dachte dann an ein Python Projekt, welches ich zusammen mit Chris vor ca. 2 Jahren mal aufgegriffen hatte. Ich fand die Idee damals schon gut, aber es mangelte einfach an Python Kenntnissen.

Ich habe dann (auch wenn es schon spät war) versucht, das nochmal in Bash abzubilden. Nur ein bisschen interessanter. Eine kleine Welt kam dabei heraus, wie schon damals ausgedacht. In dieser Welt passieren Dinge, die durch Zufall ausgewählt und gewichtet werden, was sich auf die Bewohner dieser “Welt” auswirkt. In meiner jetzigen Version sollte allerdings bisschen was passieren. Irgendwer musste da kämpfen oder sowas. Ich ließ also Zombies und Humans auf dieser Welt gemeinsam leben. Es werden neue Lebewesen geboren, sie sterben wieder, greifen einander an und so weiter.

Im Klartext habe ich nichts anderes in dieses Bash-Script gepackt als die Anzahl der Menschen/Zombies auf der Welt und eine Hand voll Funktionen definiert, die “Events” darstellen, die von einer Schleife und einem Case bei jeder Runde zufällig ausgewählt werden. Das war’s auch schon. Eigentlich hat mich mehr der Grad an Zufälligkeit interessiert, der den Verlauf der erstellten Welt beeinflusst, wie viele Zombies greifen wie viele Menschen auf einer imaginären Farm an, können sich die Menschen wehren oder werden Sie von der Übermacht der Zombies einfach überrannt? Wie viele Opfer gibt es? Wer rottet wen zuerst aus?

Das war letzten Endes auch der Punkt der mich an ZRE (so hab ich das Script genannt) immernoch unterhält und amüsiert. Jedesmal wenn ich es starte, beginnt ein total neuer Verlauf dieser Welt, wer wann wo wen angreift und letzten Endes besiegt.

Ich hab das zombie-revolution-environment auf github hochgeladen. Ich weiss nicht wirklich was es ist, aber es unterhält mich.

http://github.com/noqqe/zombie-revolution-environment
zombie-revolution-environment als RAW.

Usage ist relativ einfach.

$ wget http://github.com/noqqe/zombie-revolution-environment/raw/master/zre.bash
$ ./zre.bash

Ein beispielhafter Verlauf klemmt auch in dem github Repository.

Für neue Ideen, Bugreports, Meinungen, Flamewars oder Shitstorms bin ich wie immer dankbar.

http://github.com/jgoerzen/twidge/pull/19

twidge-sh im nächsten Ubuntu/Debian? Maybe.

Kurz: Ich brauchte eine Lösung, wie ich alle 3 Repositories (ohne History-Verlust) zusammen gemerged bekomme.

/repos/
|-- dotfiles.git
|-- scripts.git
`-- wiki.git

Hierfür hat Zrajm C Akfohg schon eine wunderbare schnelle Lösung gefunden.
Zuerst ein neues Repo erstellen:

mkdir ~/repos/noqqe.git
cd ~/repos/noqqe.git
git init

Im Grunde wird jedes Repository in einen separaten Branch gefetched:

git fetch ~/repos/dotfiles master:dotfiles
mkdir dotfiles #Subdir fuer dotfiles

Um die Files im neuen Branch jetzt in einen Unterordner umzumappen hat Zrajm auch einen wunderbaren Weg gefunden:

SUBDIR_NAME=dotfiles
BRANCH_NAME=dotfiles
git filter-branch --index-filter \
    'git ls-files -s | \
        sed "s-\t-&'"$SUBDIR_NAME"'/-" | \
        GIT_INDEX_FILE=$GIT_INDEX_FILE.new git update-index --index-info && \
        mv $GIT_INDEX_FILE.new $GIT_INDEX_FILE
    ' "$BRANCH_NAME"

Wenn alles erfolgreich war, kann man den neuen Branch mit dem Master zusammenführen:

git merge dotfiles

und das Spiel wie beschrieben von vorne beginnen.

$ twidge setup
$ twidge lsrecent
<timpritlove> Verkannt, ignoriert, nahezu vergessen - aber sinnvoll, nützlich und wertvoll: das Semikolon!
[...]
$ twidge update "Ich benutze gerade Twidge"

Bei intensiver Nutzung nervt die Syntax allerdings etwas. Deshalb hab ich mich hingesetzt und eine Twidge-Shell gebaut.

Die angepasste Shell “twidge-sh” kann einfach über Aufruf ./twidge-sh gestartet werden.

$ wget http://github.com/noqqe/twidge/raw/master/twidge-sh
$ chmod +x twidge-sh
$ ./twidge-sh
noqqe@twitter> lsrecent
<rivva> Skype jetzt für Android verfügbar – Skype Blog auf
Deutsch http://rivva.de/QajD
[...]
noqqe@twitter> update "Ich benutze gerade Twidge-Shell"
noqqe@twitter> lsdm
noqqe@twitter> follow technicallife

Die Twidge-Shell hat weiterhin folgende Features:

• Der Prompt wird aus der .twidgerc generiert (username@service>)

• Alle Standart Kommandos von Twidge werden automatisch komplettiert und sind benutzbar (z.B. user@service> lsrecent)

• Alle in der .twidgerc definierten Aliase werden übernommen und sind ebenfalls verwendbar. (z.B. user@service> rls)

• Die Twidge-Shell funktioniert weiterhin als ganz normale Shell mit allen Zusätzen und Funktionen.

Ich habe mich dabei an Ryan Tomayko’s git-sh orientiert, der ähnliches für Git gebaut hat. Was übrigens auch wirklich gut funktioniert.

Mein Twidge-Fork auf Github (mit Twidge-sh)
Twidge von John Goerzen
Twidge zum Download für Debian
Twidge zum Download für Ubuntu
Twidge-Shell Script zum Download

Da ich Twidge aber auch außerhalb des Logfiles sehr gerne benutze, behob ich das Problem durch Installieren der Testing-Version. Zu finden unter http://packages.debian.org/squeeze/twidge

$ twidge -v
[...]
This is Twidge, version 0.99.4. Copyright (c) 2008 John Goerzen

$ wget http://ftp.de.debian.org/debian/pool/main/t/twidge/twidge_1.0.5_i386.deb

$ dpkg -i twidge_1.0.5_i386.deb
Vorbereiten zum Ersetzen von twidge 0.99.4 (durch twidge_1.0.5_i386.deb) ...
Entpacke Ersatz für twidge ...
dpkg: Abhängigkeitsprobleme verhindern Konfiguration von twidge:
twidge hängt ab von libffi5 (>= 3.0.4); aber:
Paket libffi5 ist nicht installiert.
dpkg: Fehler beim Bearbeiten von twidge (--install):
Fehler traten auf beim Bearbeiten von:
twidge

$ aptitude install libffi5
Die folgenden NEUEN Pakete werden zusätzlich installiert:
libffi5
Die folgenden teilweise installierten Pakete werden konfiguriert:
twidge
Richte libffi5 ein (3.0.7-1) ...
Richte twidge ein (1.0.5) ...
Aktueller Status: 0 kaputt [-1].

Die aktuelle Version von Twidge wäre also somit installiert. Zwar mit dpkg, aber wenigstens wird nachher bei neuereren Versionen geupdated :). Twidge stellt jetzt einen (wie ich finde) hervorragend gelösten Konfigurationsweg für die neue OAuth.

$ twidge setup
Please cut and paste this URL and open it in a web browser
Click Allow when prompted. You will be given a numeric
key in your browser window. Copy and paste it here.
https://api.twitter.com/oauth/authorize?oauth_token=xxx
Authorization key: 123456789
Successfully authenticated!
Twidge has now been configured for you and is ready to use.

Hat irgendwie fast ein bisschen was von Wizard ;). Im Endeffekt sind es aber nur ein paar kleine Schritte:

• Url öffnen
• “App” autorisieren oder “Erlauben”
• App-Authkey kopieren
• Twidge vorwerfen

Danach kann man das Internet wieder mit dem eigenen daily Nonsense füllen. Mit einem CLI-Client :). Was mich nebenbei noch fasziniert hat: http://packages.ubuntu.com/search?lang=de&searchon=names&keywords=twidge . Es gibt Twidge für Ubuntu also für Jaunty, Karmic und Maverick. Warum nicht für Lucid? Ich konnte es in meinen Quellen in Xubuntu (Lucid) auch nicht finden.

$ curl -Is slashdot.org
HTTP/1.1 200 OK
Server: Apache/1.3.41 (Unix) mod_perl/1.31-rc4
SLASH_LOG_DATA: shtml
X-Powered-By: Slash 2.005001
X-Fry: You'll barely regret this.
X-XRDS-Location: http://slashdot.org/slashdot.xrds
Cache-Control: no-cache
[...]

Bei so ziemlich jeder Anfrage steht an der Stelle ein neues Zitat. Da ich sowieso total auf Futurama stehe, dachte ich mir ich baue die Zitate als Welcome-Message in meine Rechner ein:

$ curl -Is slashdot.org | sed -n '5p' | sed 's/^X-//'
Bender: OK, but I don't want anyone thinking we're robosexuals.
$ curl -Is slashdot.org | sed -n '5p' | sed 's/^X-//'
Fry: I can burp the alphabet. A, B, D ... no, wait ...

Wenn ich aber bei allen meinen Rechnern die Zeile einbinde, hat das irgendwie ein bisschen was von DOS-Attacke. Muss ja nicht sein. Mit einem Einzeiler hab ich mir die Quotes erstmal alle besorgt:

target="/path/to/file/018" ; while true ; do quote="$(curl -Is slashdot.org |sed -n '5p' |sed 's/^X-//')" ; if [ $(grep "$quote" $target |wc -l) -lt 1 ]; then echo $quote >> $target ; echo $quote ; sleep 1 ; fi ; done

Hier gibt’s alle Quotes die der Einzeiler bis jetzt gesammelt hat: http://zwetschge.org/paste/018

Futurama Quotes beim Login unter Ubuntu:

$ wget http://zwetschge.org/paste/018 -O ~/.futurama
$ vi ~/.bashrc
quotes="$HOME/.futurama"
if [[ $- == *i* ]]; then
echo " "
rnd=$((RANDOM % $(cat $quotes | wc -l)+3)) ; sed -n "${rnd}p" $quotes
fi

Einloggen oder Shell starten sieht dann wie folgt aus:

$ ssh user@host
user@host password:
Linux host 2.6.32-22-generic #33-Ubuntu SMP Wed Apr 28 13:27:30 UTC 2010 i686 GNU/Linux
Ubuntu 10.04 LTS
[...]
You have new mail.
Bender: You can't count on God for jack! He pretty much told me so himself.
user@host:~$

Das sich gerade formierende Hobby-Eishockey-Team, dem ich angehöre, war bisher ohne großartige HomePage ausgekommen. Es bestanden kleine Basteleien unseren Captains, aber so wirklich vollständig war das dann auch nicht. Ich machte mich auf die Suche nach einem minimalen CMS. Irgendwas kleines Schönes, in dem wir unseren minimalen Content unterbringen können. Ausmaße wie etwa Mytinytodo für Todo-Listen (von dem ich sehr begeistert bin ;) ). Ich wurde nicht wirklich fündig. Alle Tipps die ich bekam waren zu umfangreich und somit einfach Overkill.

Die Sache schlief irgendwie 1-2 Monate ein, bis ich von der Markdown-Language gehört habe. Diese Mischung aus .txt-File Syntax und HTML-Generator gefiel mir und ich dachte wieder an die Hockey-Page. Muss es immer PHP und SQL sein? Eigentlich nicht.

Der Plan war: In einen Unterordner content/ für jede Seite ein *.markdown-File zu laden, aus welchem generisch die .html Files gebaut werden. Umgeben Natürlich von header.tmpl und footer.tmpl. Auf dem Filesystem sieht das in etwa so aus:

|-- content
|   |-- 001.impressum.markdown
|   |-- 001.index.markdown
|   `-- 002.index.markdown
|-- css
|   |-- readme.txt
|   `-- style.css
|-- impressum.html
|-- index.html
|-- tismc.bash
`-- tmpl
      |-- footer.tmpl
      `-- header.tmpl

Ein kleines Bashscript durchsucht den content/-Ordner und baut für jedes gefundene .markdown-File die HTML-Page.

$ ./tismc.bash
page-dir is now /path/to/homepage
--- parsing impressum.html
adding header
parsing content/001.impressum.markdown
adding footer
--- parsing index.html
adding header
parsing content/002.index.markdown
parsing content/001.index.markdown
adding footer

So kann auch mein Captain oder andere Dritte, neue Inhalte in die Page hochladen. Denn Markdown-Syntax ist nicht wirklich kompliziert. Allerdings gab es da noch ein Problem. Eigentlich drei. Die hießen header.tmpl, footer.tmpl und style.css. Ich bin in solchen Design-Dingen sehr schlecht, aber mein Berufsschulkollege Holger, der öfters mal wunderschöne Templates aus dem Ärmel schüttelt, sagte natürlich nicht nein und erstellte mir die nötigen Files <3. Unter http://ice-bullocks.zwetschge.org kann man das Ergebnis begutachten. Sind Leberkäse-Brötchen eigentlich anerkannte Währung unter Designern ?

Den Source zum Anschauen gibts unter:
bash-script
Homepage-Dir

Wenn man dieses Gebiet via Google Maps nun genauer unter die Lupe nimmt stellt man fest, dass ziemlich rechteckig um diesen Übungsplatz herum eine deutlich weniger hohe Auflösung verfügbar ist als für die restliche Umgebung.

Zur Veranschaulichung eine Map (vollständiger Link)

Grafenwöhr Truppenübungsplatz auf einer größeren Karte anzeigen

Wer kurz damit herumspielt erkennt, dass nicht mal ein Haus in nahe gelegenen Städten durch den Zoom auszumachen ist. Und wird Google hier wohl eines von ihren Street View-Autos durch schicken ? Eher nicht.

Interessant finde ich aber, von wem diese regionale Zensur ausgeht und wieso. Aus Angst vor Terror?

Wie dem auch sei. Google Street View ist für mich kein Thema.

watch hat die blöde Angewohnheit, den aktuellen Screen immer zu leeren. Gerade beim oberen Beispiel ist das von Nachteil (IP-Konflikt nachvollziehen), da der Vergleichswert wegfällt. Quick&Dirty die Lösung:

while true; do arp -a | grep 192.168.1.12 ; sleep 0.2 ; done
\_________/ |  \____/  \________________/   \_______/  \____/
     |      |     |             |               |         |
     |      |     |             |               |         \- Schleifenen
     |      |     |             |               |            de
     |      |     |             |               |
     |      |     |             |               \- danach 0.2 Sekunden
     |      |     |             |                  pausieren
     |      |     |             |
     |      |     |             \- nach bestimmter Adresse suchen
     |      |     |
     |      |     \- arp-table ausgeben
     |      |
     |      \- fuehre aus
     |
     \- bis strg+c

Explain versucht Shell Kommandos zu erklären und zu visualisieren. Gerade für Blogs oder andere Dokumentationen finde ich das mehr als sinnvoll. Es erstellt aus einem simpel gestricktem Markdown File eine ASCII-Art ähnliche Erläuterung des Kommandos. Beispielsweise:

$ ./explain.py command.markdown
find . -iname '*.png' -exec echo '<br><img src="{}">' \; > gallery.html
\__/ | \___________/  \________/ \___________________/ |  \___________/
  |  |       |             |               |           |        |
  |  |       |             |               |           |        \- Ausgeben nach
  |  |       |             |               |           |           gallery.html
  |  |       |             |               |           |
  |  |       |             |               |           \- find Syntax Ende.
  |  |       |             |               |
  |  |       |             |               \- mit folgendem Inhalt aus.
  |  |       |             |
  |  |       |             \- und führe echo
  |  |       |
  |  |       \- alle Dateien die mit .png enden
  |  |
  |  \- im aktuellen Verzeichnis
  |
  \- Finde (via find)

(PlainText: http://zwetschge.org/paste/015)

Die Syntax des Files das zur Deklaration der Ausgabe dient:

find . -iname '*.png' -exec echo '<br><img src="{}">' \; > gallery.html
---- ! -------------  ---------- --------------------- ! -------------

Finde (via find)

im aktuellen Verzeichnis

alle Dateien die mit .png enden

und führe echo

mit folgendem Inhalt aus.

find Syntax Ende.

Ausgeben nach gallery.html

Die Trennzeichen  sind via Parameter austauschbar und auch ansonsten tut das kleine Python Script seinen Job hervorragend. Sollte demnächst mal wieder ein Kommando erläutert werden müssen, werde ich definitiv darauf zurückgreifen. Weitere Beispiele auch unter:

[1] http://www.uninformativ.de/?section=news&ndo=single&newsid=118
[2] http://github.com/vain/explain

Wenn man seinen Public-Key also Gitosis zur automatischen Authentifizierung vorwirft, wird man in das System der Git-Benutzer eingespeißt.

cp id_rsa.pub ~/gitosis/keydir/user@host.pub
git add keydir/*
git commit -a -m "user hinzugefügt"
git push

Bei erneuter Anmeldung an das System passiert folgendes:

$ ssh user@gitserver.domain.com
PTY allocation request failed on channel 0
ERROR:gitosis.serve.main:Need SSH_ORIGINAL_COMMAND in environment.
Connection to git closed.

Ich darf mich also nicht mehr einloggen. Bin ich normaler Benutzer, der wirklich nur mit git arbeiten darf, ist das auch gut so. Denn so wird die Sicherheit des Systems gewahrt. Bin ich allerdings Administrator des git-Remote-Servers sieht das anders aus. Ich habe ab diesem Zeitpunkt keine Möglichkeit mehr mein System (auf gewohntem Wege) zu pflegen.

Die Verbose-Ausgabe von ssh lässt darauf schließen was passiert:

$ ssh -v user@gitserver.domain.com
debug1: Authentications that can continue: publickey,password
debug1: Next authentication method: publickey
debug1: Trying private key: /home/user/.ssh/identity
debug1: Offering public key: /home/user/.ssh/id_rsa
debug1: Remote: Forced command: gitosis-serve user@host
debug1: Remote: Port forwarding disabled.
debug1: Remote: X11 forwarding disabled.
debug1: Remote: Agent forwarding disabled.
debug1: Remote: Pty allocation disabled.
debug1: Server accepts key: pkalg ssh-rsa blen 277
debug1: read PEM private key done: type RSA
debug1: Remote: Forced command: gitosis-serve user@host
debug1: Remote: Port forwarding disabled.
debug1: Remote: X11 forwarding disabled.
debug1: Remote: Agent forwarding disabled.
debug1: Remote: Pty allocation disabled.
debug1: Authentication succeeded (publickey).
PTY allocation request failed on channel 0
ERROR:gitosis.serve.main:Need SSH_ORIGINAL_COMMAND in environment.
debug1: client_input_channel_req: channel 0 rtype exit-status reply 0
debug1: client_input_channel_req: channel 0 rtype eow@openssh.com reply 0
debug1: channel 0: free: client-session, nchannels 1
Connection to git closed.

Die Authentifizierung mit meinen Public-Key klappt zwar, aber ich werde in eine gitosis-serve ssh-session gezwungen und damit bleibt mir der ssh-zugang ins System verwehrt. Nicht mit dieser Situation rechnend, starrte ich völlig perplex auf mein Terminal und die Reverse-Engeneering-Abteilung in meinem Kopf ratterte vor sich hin. Was passiert da und warum passiert das? Und vor allem: Wie komme ich jetzt wieder auf den Server?

Solve it!

1. Public-Key Auth deaktivieren
Ohne PubKey Auth, wird der ssh-daemon nicht erkennen, das er mir eine git-serve session geben müsste. Dem lokalen ssh-client beizubringen sich nicht mit dem Public-Key am entfernten System anzumelden, wäre also eine Lösung (aber keine Schöne). Folgende Konfiguration führt dazu.
$ vi ~/.ssh/config
Host git
HostName gitserver.domain.com
User root
pubkeyauthentication no


2. Different User
Die Alternative zu dieser dauerhaften Veränderung ist (wenn vorhanden) einen anderen Benutzer zu verwenden um sich ins System einzuloggen und erst anschließend zu root zu werden.

3. gitosis-serve zurechtstutzen
Nachdem der Zugriff auf das System  wiederhergestellt ist, gehts zum Bugfix (gitosis-serve). gitosis muss diesen Umstand in irgendeiner ssh-config erzwingen. Ich verstehe nicht ganz warum, aber gitosis schrieb mir diese Änderungen in /root/.ssh/authorized_keys.

command="gitosis-serve user@host",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AABBB3NzaC1yc2EAAAABIwAAAQEAyjwZCinCmB4oJJZ4RuiSqrQmiYE8+C+JKpTmiPkdfojUbiB9gm3BOhsYAdu99vP7yDOaIqg9e2dk/4HGm+P8obUR7lVrinMf5NvoRkOa8EfGdPJRz4ABOGRDte454bwestyWlvLhnKyWd+a9lU07siDJg5b1NbitIXkXa76V+lGMrqkixaDC6meZQEjZlxnVMpgzC5wyEQy2cVwUnX+Swiw68gsHsMYKBNsiVgNQ7nY8fa5lhV13E6L2aYAIorVpudS1bTiQfvfXCpVtJkJVSNPP6RzUtuSSErhsqOn1o2QtVjWhH5J/Y0D1b4eeEAgmdhq7554kQupJ9LgRww== user@host

Dieser Eintrag ist für das Verhalten verantwortlich. Auskommentieren oder entfernen aller Parameter bis ssh-rsa fixt das Problem . Happy Committing.

Datei ging gerade eben verloren
aus aktuellem HEAD wiederherstellen:
$ git checkout HEAD -- verloren.txt

Datei hat vor gewisser Zeit einmal existiert
Aus vorher gegangenem Commit, Branch oder Tag. Feststellen, wo das File noch existiert haben könnte:
$ git log --oneline
5aadc10 formatierte Ausgabe
88e22fb Aufräumaktion
746f92c bugfix #1234
ee8a1da initial commit

Vorletzter Commit 88e22fb betitelt mit “Aufräumaktion” lässt stark darauf schließen, dass hier etwas verloren gegangen sein könnte. Checkout lässt sich eigentlich mit so ziemlich allem füttern, was ein Object ist und anhand eines SHA1 Hashwertes identifizieren lässt. Gewählt wird der Commit vor der Aufräumaktion.

git checkout 746f92c -- verloren.txt

Nachdem die Datei nun wieder im aktuellen Working-Directory liegt:

via git-add hinzufügen
git add verloren.txt

und Commit absetzen.
git commit -a -m "Ich werde ab jetzt besser aufpassen"

“Warum funktioniert mein Alias hier eigent…..ah. Falscher Host :/ “

Das brauche ich hier warscheinlich niemandem weiter erläutern ;)

Grundsätzlich bemühte ich mich einen kleinen Satz ausgewählter .dotfiles meiner Home-Verzeichnisse auf neue Systeme zu kopieren bzw zu aktualiseren. Aber bei einer Änderung >4 Hosts neu umkopieren? Oder Änderungen sogar per Hand separat ausführen? Jedenfalls entwickelt mit der Zeit jeder, der auf diese Problemstellung trifft, seinen eigenen Weg alle Dotfiles synchron zu halten. Hier ist nun der (seit neuestem) Meinige.

Ich benutze ein Git-Repository. In diesem Repo befinden sich alle Dotfiles die ich im alltäglichen Gebrauch benötige. Das sieht ungefähr so aus:

dotfiles/
|-- .bashrc
|-- coming-home.bash
|-- .csshrc
|-- .dircolors
|-- .dmrc
|-- .git/
|-- .gitconfig
`-- .vimrc

(Aus Gründen der Lesbarkeit gekürzt)

Alle Änderungen, die für die Configs anstehen, kann ich nun hier tätigen. Füge neue Aliase hinzu, ändere meine Editor einstellungen für Vim oder ähnliches. Für die automatische Einrichtung habe ich “coming-home.bash” geschrieben. Das Script filtert automatisch alle Verzeichnisse(., .., .git) und Files (z.B. das Script selbst) die nicht ins $HOME-Verzeichnis gehören und kopiert alles was übrig bleibt in das Home-Dir des aktuellen Benutzers.

#!/bin/bash
# get dotfiles
dotfiles=$(ls -la | grep -v ^d | awk '{print $8}'| grep -v ^coming-home.bash$ )
mode=${1:-normal}

for x in $dotfiles; do
    # fishing errors
    if [ ! -e $x ] ; then echo "error reading files" ; exit 1 ; fi
    # keep old .bashrc
    if [ $x = ".bashrc" ]; then
        if [ ! -e $HOME/.bashrc_old ]; then
            cp $HOME/.bashrc $HOME/.bashrc_old
        fi
    fi
    # forced hook
    if [ $mode = "--hook" ]; then echo "hook: copying $x" ; /bin/cp -r $x $HOME/ ; fi
    # standard run
    if [ $mode != "--hook" ]; then /bin/cp -i $x $HOME/ ; fi
done

Git bietet weiterhin noch schöne Möglichkeiten, Operationen bei Änderungen automatisch ausführen zu lassen. Hooks. Ein post-commit-Hook führt das Skript jetzt nach jeder eingespeicherten Änderung automatisch aus.

.git/hooks/post-commit:

#!/bin/bash
$GIT_DIR/../coming-home.bash --hook

Anwendungsbeispiel:

$ git commit -a -m "added aliases and changed colors in vimrc"
hook: copying .bashrc
hook: copying .csshrc
hook: copying .dircolors
hook: copying .dmrc
hook: copying .gitconfig
hook: copying .vimrc

So kann ich jetzt Änderungen der Dotfiles im Git-Repo durchführen und habe diese gleich darauf im Home-Verzeichnis. Dieses Repo existiert (über einen Git-Server verwaltet) auf jedem meiner Hosts. Um im Fallbeispiel zu bleiben: Gehe ich morgen in die Arbeit, aktualisiere ich das (auch dort vorhandene) Repo und führe coming-home.bash aus.

By the Way: An dieser Stelle habe ich auch über Automatisierung nachgedacht. Git-Hooks gibt es für die verschiedensten Situationen:

Pre-Commit (vor speichern einer Änderung)
Post-Update (Nach dem pushen auf den Server)
usw.

Für eine Situation darf es diese Automatisierung aber nicht geben. Nämlich nach dem post-clone (unmittelbar nach dem Herunterladen eines Repos). Automatische Skripte die nach dem Herunterladen ausgeführt werden könnten große Schäden anrichten, wenn man so drüber nachdenkt.

Bash-Script: http://gist.github.com/525385

ESC=$(printf "\e")
echo "$ESC[34;47mDATE$ESC[0m"
date
echo ""
echo "$ESC[34;47mUPTIME$ESC[0m"
uptime
echo ""
echo "$ESC[34;47mSTATUS$ESC[0m"
top -l1 -u -o cpu -S | head -n 12
echo ""
echo "$ESC[34;47mEstablished$ESC[0m"
lsof -i -n | grep -i established | awk '{print $1" "$8" "$9 }' | head -n 18
echo ""
echo "$ESC[34;47mListen$ESC[0m"
lsof -i -n | grep -i listen | awk '{print $1" "$8" "$9 }' | head -n 18 

Besonderheit hierbei: Der Escape-Character muss so _zwingend_ wie beschrieben eingesetzt werden. Normale Ausgabe wird nicht entsprechend wahrgenommen. Er ist nötig um die Farbtöne innerhalb des Scripts zu managen ;)

Also im Klartext: Ich finde Gitosis super. Der Ansatz ist gut. Definierbare Rechte und Gruppenorganisation für Git-Repositories. Im Web findet man unzählige How-To’s die eine Standardinstallation wirklich gut und übersichtlich dokumentieren bzw. dazu anleiten. Speziellere Anpassungen und kleinere Grauzonen hingegen leider gar nicht.

Um den Überblick über kleinere Mängel zu behalten und auch zu dokumentieren:

(1) post-update – Hook-Problematik

Die Funktionsweise von Gitosis ist eigentlich denkbar simpel. Konfigurationsdatei syntaxgerecht anpassen und innerhalb des admin-repos committen+pushen. Ist die neue Config gepusht und der Benutzer bzw. das neue Repo nicht ansprechbar, verbringt man lange Zeit damit, Configs und Pubkeys (siehe 2) zu kontrollieren und erneut zu initialisieren. An dieser Stelle begegnet einem schon das erste Problem, welches Kenntnis über die Funktionsweise von Gitosis voraussetzt und hervorragend schlecht dokumentiert ist.
ERROR:gitosis.serve.main:Repository read access denied fatal: The remote end hung up unexpectedly
Nach dem das Master-Repo die gepushte Version von Gitosis erhält, führt es einen sogenannten Hook aus. Dieser Hook ist ein Skript (bzw. ein Symlink dazu) welches die neue Konfiguration der Authentifizierungsstelle von Gitosis einließt. Der erste Fehler der (wirklich häufig) passiert ist, dass dieses Skript schlicht weg einfach nicht ausführbar ist. Das lässt sich natürlich sehr einfach durch

chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

lösen. Aber der knackende Punkt stellt (wie ich finde) die fehlende Meldung dieses Fehlers dar. Gitosis teilt einem einfach nicht mit, dass der Hook fehlschlug und die getätigten Änderungen komplett für die Katz waren.

(2) Pub-Key-Format

Ein weiteres undefiniertes Loch der Konfiguration ist das Format, in dem der PublicKeys im conf-File angegeben werden muss.

Abgelegte Keys in gitosis-admin.git/keydir/ müssen mit .pub enden. Sonst werden diese nicht als Keys erkannt. Das ist das kleinere Übel. Die, für mich etwas unklare, Dokumentation darüber findet sich in den verschiedensten Varianten. Wie soll der PublicKey in der gitosis.conf hinterlegt werden?

“Wer wird Millionär”-mäßig kann ich jetzt nach dem Trial-and-Error-Verfahren auflösen. Die endlosen Variationen von Filenamen und Config-Aufruf, die ich testen musste, damit ich mich anmelden durfte, haben sich also gelohnt.

(3) Gitosis, sprich mit mir.

Ein weniger behütetes Geheimnis, ist die Gesprächigkeit von Gitosis. Im Konfigurationsfile lässt sich das LogLevel deklarieren.
[gitosis]
loglevel = DEBUG
gitweb = no
git-daemon = no

Siehe da, Informationen!

DEBUG:gitosis.serve.main:Got command "git-receive-pack 'repo1'"
DEBUG:gitosis.access.haveAccess:Access check for 'user@domain.com' as 'writable' on 'repo1'...
DEBUG:gitosis.group.getMembership:found 'user@domain.com' in 'domain.com'
DEBUG:gitosis.access.haveAccess:Access ok for 'user@domain.com' as 'writable' on 'repo1'
DEBUG:gitosis.access.haveAccess:Using prefix 'repositories' for 'repo1'
Initialized empty Git repository in /home/git/repositories/repo1.git/
DEBUG:gitosis.gitdaemon:Global default is 'deny'
DEBUG:gitosis.gitdaemon:Walking '.', seeing ['repo1', 'repo2', 'repo3', 'gitosis-admin.git']
DEBUG:gitosis.gitdaemon:Deny 'gitosis-admin'
DEBUG:gitosis.gitdaemon:Walking 'repo1', seeing ['justatest.git']
DEBUG:gitosis.gitdaemon:Deny 'repo1/justatest'
DEBUG:gitosis.serve.main:Serving git-receive-pack 'repositories/repo1.git'

Diese Infos werden nun zu fast jeder Gelegenheit ausgegeben. Pushen lokal, Authentifizieren per Remote usw. Für weitere Administration mit Gitosis unabdingbar.

(4) Subdirectories handhaben

Angenommen ich habe oder möchte eine Ordnerstruktur meiner Projekte die nicht alle in repositories/ liegen. Dieser kleine total untriviale Umstand, lässt sich einfach nirgends nachlesen. Um das Ganze zu verdeutlichen, habe ich kurz eine kleine Umgebung angelegt und mit tree -L 2 ausgegeben:

`-- repositories
    |-- subdir1
    |   |-- repo1.git
    |   |-- repo2.git
    |   `-- repo3.git
    |-- subdir2
    |   `-- test.git
    `-- subdir3

Angelege und initalisierte Repos werden zwar in der DEBUG-Ausgabe von Gitosis wargenommen (siehe 3.), aber einfach übergangen. Stattdessen wird ein neues Repo in repositories/ angelegt. Zumindest, wenn man der Konfiguration folgt, wie sie in 95% der Fällen im Netz zu finden ist. Als Faustregel für Unterordner gilt also: Zwingend jeden(!) Pfad mit Angabe des Subdirs angeben.
Remote add:
git remote add origin git@gitserver.org:subdir1/repo2.git
gitosis.conf:
[group subrepo]
members = user@host.com
writable = subdir1/repo2.git

Es klingt logisch. Aber ohne Dokumentation, ist es hart herauszubekommen.

Letztlich möchte ich kurz noch erwähnen, dass dieser Post keinerlei Vorwurf, Flame oder Sh!t-Storm gegen Gitosis darstellen soll. Gitosis ist ein wunderbarer Ansatz einer Benutzerverwaltung für Git-Remotes. Allerdings abenteuerlich bei nicht alltäglicher Nutzung. In diesem Sinne. Happy committing.

SSH: 2,99€ Sendet anscheinend falsche Daten an das Terminal und macht somit kein top, screen usw möglich. Ansonsten selbe Probleme wie bei pTerm.

iSSH: Kostenpunkt 7,99€ und integrierter VNC-Client, der (wie man Bewertungen entnehmen kann) nicht mal gut ist. Ich brauche einfach keinen integrierten VNC-Client und der Preis ist irgendwie…utopisch. SSH-Client soll aber gut funktionieren

ssh-terminal: 0,79€ Endlich ein normaler Preis. Allerdings auch hier wieder wenig bis keine Anpassungsmöglichkeiten und diverse Probleme in der Kommunikation. Hier allerdings die geringsten Einschränkungen.

Ich muss wirklich sagen, dass ich so gut wie allen APPs dieser Liste misstraue. Ich möchte es nicht Paranoia nennen, aber bei dem Gedanken den Zugang zu meinen Servern irgendeiner zwielichtigen datensammelnden Applikation anzuvertrauen, sträubt sich bei mir alles. Man sollte denken, Apple kontrolliert die Programme, die den Weg in deren App-Store finden auf Fehler und Spyware. Aber gestern erst musste ich lesen, wie ein 15 Jähriger mit einer Taschenlampen-App das iPhone hinterrücks zu einem Tethering-Modem umfunktioniert hat.

Soviel zum Thema Kontrolle also. Ich weiss nicht, für das nötigste hab ich mir die App mit dem besten Preis-/Leistungsverhältnis gekauft (ssh-terminal). Ob ich da aber mein Passwort wirklich speichern will, weiss ich nicht. Allein schon, weil mir mein Telefon auch mal verloren gehen kann.

Um am Webserver alle zugleich betrachten zu können, fiel mir ein Bash Einzeiler ein, den ich bei commandlinefu.com gesehen hatte und eine (zwar bisschen dürftige aber funktionierende) Gallery erstellt.

find . -iname '*.png' -exec echo '<br><img src="{}">' \; > gallery.html

Für jedes File mit der Endung .png im PWD wird ein HTML-Image in gallery.html eingefügt. Um Meinungen (zum Einzeiler als auch den Buttons^^) wird gebeten.

http://zwetschge.org/statics/einfachjabber/gallery.html
http://zwetschge.org/statics/einfachjabber/

Das funktioniert so lange, bis einmal recovered werden muss. Alle DB’s neu einspielen ist dann doch irgendwie kein Spass. Weder von der Dauer noch vom Datenverlust. 25 MB sind jetzt zwar nicht die Welt, aber trotzdem doof wenn etwas verloren geht. Deshalb kombinierte ich mein Voll-Backup mit einem File pro DB. Folgendes Script dient dazu:

#!/bin/bash
pass=
backuppath=/var/cache/mysqlbackups

mysqldump --password=$pass --all-databases > ${backuppath}/$(date +%Y-%m-%d).sql
return1=$?

for x in $(mysql --password=$pass -Bse 'show databases'); do
mysqldump --password=$pass $x > ${backuppath}/$(date +%Y-%m-%d)-${x}.sql
done
return2=$?

if [ $return1 -eq 0 ] && [ $return2 -eq 0 ]; then
logger -p local0.info -t MYSQLBACKUP MySQL Backup successful
else
logger -p local0.err -t MYSQLBACKUP MySQL Backup failed
fi

Ausschlaggebender Teil ist die for-Schleife. Für jede Zeile Output von “show databases” wird ein seperates .sql File erstellt. Versehen mit Datum und DB-Name. Nebenbei wird auch noch via logger in /var/log/syslog geloggt.

http://www.3dsupply.de/products/783-planet-express/

Mein Kaufbedürfnis ohne Absichten bei Twitter gepostet und wurde komischerweise mit Gutscheincode beantwortet O_o

3dsupply: @noqqe Hier ist dein 2,50 Euro Gutscheincode: cqfr-lUEq-uWzY-vdDc Einfach im Warenkorb einlösen. :D

Fand das gut. 2,50 € sind nicht die Welt, aber hätte auch einfach ignoriert werden können.
Wer kennt das eigentlich, wenn absolut keine Motivation vorhanden ist, grammatikalisch richtige Sätze zu bilden?

Grundgedanke: Boxen aufstellen und iPhone || x-beliebigen MP3-Player per Klinkenstecker anschliessen und Musik genießen.

Ich muss eigentlich bevor ich den Post weiter tippe, darauf hinweisen das ich elektrotechnisch in etwa so viel Ahnung habe wie ein durchschnittliches Lebewesen aus der Kreidezeit. Also eine ziemliche Null. Die letzten 2-3 erhaltenen Zentimeter der Boxenkabel, liessen sich gerade noch so abisolieren und weiterverwenden. Also habe ich ein Klinkenkabel von Hama (Stecker auf Stecker) aus meiner Kabelkiste raus gefischt, ebenfalls ab-isoliert und mittels einer Lüsterklemme beide Kabelpaare zusammen geführt.

Ich weiss weder, ob man das so praktizieren darf, sollte, ob es im Grunde sowieso das selbe Kabel ist oder ich mich jetzt in ständiger Lebensgefahr befinde. Was ich aber nach der Aktion mit Sicherheit sagen kann: Es kommt da Ton raus, wo es soll. Operation geglückt. Bass lässt bisschen zu wünschen übrig, ansonsten aber absolut awesome.

Bei Flickr hab ich ein kleines Fotoalbum erstellt, über Kommentare oder Überlebenshinweise würde ich mich freuen.

http://www.flickr.com/photos/flooohooo/sets/72157624528623244/

Update: Bin mir bewusst, dass ich passive Boxen ohne Zusatzstromquelle betreibe :)

Gigolo möchte also Thunar zum Öffnen dieser Orte benutzen (voreingestellt). Allerdings unterstützt Thunar in der in Xubuntu vorliegenden Version noch keine Netzwerk-Ressourcen. In diversen Threads bei UbuntuUsers fand ich auch Lösungsansätze die empfahlen Nautilus zu installieren. Aber ich finde Thunar schön, weshalb ich mich gegen diesen Ansatz entschied. Nachdem ich mich dann (erneut) 20 min durchs Netz gegreppt habe, fand ich eine Alternative.

Die aktuelle Entwicklerversion von Thunar setzt auf Gio auf. Dem selben Manager den auch Nautilus für Netzwerksachen nutzt.

Zu finden ist diese unter: https://launchpad.net/~xubuntu-dev/+archive/ppa

Neue Sources in /etc/apt/sources.list hinzugefügt

deb http://ppa.launchpad.net/xubuntu-dev/ppa/ubuntu lucid main
deb-src http://ppa.launchpad.net/xubuntu-dev/ppa/ubuntu lucid main

und Thunar updaten. Gigolo kann mittels Thunar die eingebundenen Ressourcen öffnen. Gigolo funktioniert. Tada.

Allerdings interessiert es mich trotzdem, ob ich einfach nur Fehler im Handling mache oder da seitens Xubuntu etwas Abstimmungstechnisches schief lief. Immerhin ist es schon die zweite Xubuntu Installtion bei der dieser Umstand eintritt.

einfachJabber.de

Außerdem finde ich, dass die technische Umsetzung des Portals glänzt. Der SourceCode der Plattform ist einsehbar unter:

http://github.com/zeroathome/step-by-step

Und genauso schön hat er es auch geschafft für Dritte Mitarbeiter am Projekt die Arbeit zu erleichtern. In Form eines .json-Vorlagenformats für HowTo’s. Die Tutorials des Projekts befinden sich in einem separaten Git-Repository:

http://github.com/zeroathome/jabber-tutorials

So stehen alle Inhalte dieses Portals unter einer Creative Commons License und dürfen wieder verwendet werden. Inder LibreList gibt es die Mailingliste einzusehen mit aktuellen Requests und Neuigkeiten sowie Kritik und Lob

http://librelist.com/browser/einfachjabber/

Über Hilfe freuen wir uns natürlich immer, wer möchte darf sich gerne melden. :)

George Notaras hat für grub 1 und 2(!) folgende wunderschöne Tabelle gebastelt.

     | 640x480  800x600  1024x768 1280x1024
----+-------------------------------------
256 |  0x301   0x303    0x305    0x307
32k |  0x310   0x313    0x316    0x319
64k |  0x311   0x314    0x317    0x31A
16M |  0x312   0x315    0x318    0x31B

Dieser Hex-Wert muss als zusätzlicher Parameter in /boot/grub/menu.lst an den Kernel angehängt werden. Folgendermaßen kann sowas aussehen:
kernel /boot/vmlinuz-2.6.26-2-686 root=/dev/ida/c0d0p1 ro vga=0x318 quiet

Aktuell für Grub 2: /boot/grub/grub.cfg. Sieht bisschen anders aus, funktioniert aber genauso:
linux /boot/vmlinuz-2.6.32-22-generic root=UUID=92892dbf-af24-4dbd-b2a4-8debdbb08981 ro vga=0x318 quiet splash

Sollte es eventuell noch eine schönere Möglichkeit für Grub 2 geben (was ich mir durchaus vorstellen kann) bitte ich diese doch kurz zu kommentieren :)

Perl hat angefangen mich zu interessieren. Oder anders rum? Vor … ca. einem viertel Jahr. Ich las teilweise kurz How-To’s und auch mal längere Beschreibungen, weil mir manchmal die Schwerfälligkeit und nicht vorhandene Flexibilität von Bash auf den Keks ging.

Das mittlerweile als etwas veraltete Skriptsprache für Administratoren gehandelte Perl hat mich neugierig gemacht. Die Module, die Handlichkeit im Umgang mit Strings, Hashwerten und RegExp gefielen mir. Beim herumexperimentieren damit bin ich nun auf den PerlGuide vom deutschen Perlboard gestossen. Ein wunderschönes Tutorial. Jedes Kapitel endet mit Übungen, Praxis-Programmen und Zusatzfragen.

print "Perl hat manchmal geile Syntax" and die if ! defined @ARGV ;

Danach, fand ich brauchte ich noch ein Buch. Also ein analoges Medium aus dem ich auch mal auf der Couch lesen kann. Meine Wahl fiel nicht (wie meistens) auf ein O’Reilly Buch. Sondern auf das bereits oben erwähnte Programmieren in Perl. Nachher erfuhr ich (unter anderem aus dem wunderbaren 1. O’Reilly Podcast mit Tim Pritlove) dass das Perl-Buch von O’Reilly eines der Besten sein soll, die dort je herausgebracht wurden.

Bereue meinen Kauf. Allerdings mache ich trotzdem Fortschritte mit Perl. Wie immer arbeite ich mit den Skripten in einem Git-Repo. Wen’S intressiert: git.zwetschge.org

Ich bemühte Google nach freien Schriftarten. Wurde auf eine japanische Seite weitergeleit. 8-Bit-Fonts. http://mfs.sub.jp/. Vanilla Ice gefiel mir wunderbar. Genial einfach und C64-Kompatibel.

Die Terms of Use waren mir aber irgendwie ein Rätsel. http://mfs.sub.jp/info.html war das einzige, was auf japanisch dort stand.

Google Translate hat mir dann geholfen:

- Unerlaubte Vervielfältigung umgeleitet, um Daten auf unserer Website bitte nicht replizieren
- Kostenloses Web Klüngel Aktivitäten und groß angelegte nicht-materielle Verteilung, die Schriftart für Non-Profit-Aktivitäten Bitte zögern Sie nicht verwendet
- Und Bücher auf die gewerbliche Nutzung von Schriften und sonstigen Anfragen zur Gestaltung der Arbeit danken Ihnen per E-Mail.

So sieht das jetzt nämlich aus. Ich bin ja non-commercial ;). Und ich hab das Banner mit Gimp erstellt. Weil ich so OpenSource bin.

Grüße aus einer Englisch-Schulstunde,
Flo

Alles in allem wurden die Änderungen so umfangreich, dass es dem Orginal überhaupt nichtmehr ähnelt. Genau genommen ist es nichtmal mehr “cloudy”. Trotzdem hab ich mir in den letzten Wochen immer wieder ein Stückchen Zeit genommen und das Theme massentauglich gemacht. Rausgekommen ist das WordPress-Theme “nerd-clouds”.

Auch wenn ich mit folgendem nicht gerade Werbung für das Theme mache, muss ich sagen: Ich war noch nie besonders gut in diesem HTML / CSS / PHP Dings, welches man eigentlich können sollte, wenn man so ein Theme released. Trotzdem scheint es so, als würde es (auch der Code^^) im Test-Einsatz ein relativ gutes Bild abgeben.

Das nerd-clouds Theme gibts zum Download und beobachten unter
http://github.com/noqqe/nerd-clouds oder
http://git.zwetschge.org/?p=nerd-clouds.git;a=summary

Wie Ali, steht auch mein Theme unter Creative Commons CC-BY-SA-NC.
Alle Feinheiten und Handling-Tipps stehen im Readmefile.

Beschreibung der Fächer mit snmpwalk abholen:
snmpwalk -Os -c public -v 1 192.168.1.200
mib-2.43.11.1.1.6.1.1 = STRING: "Toner Schwarz"
mib-2.43.11.1.1.6.1.2 = STRING: "Resttoner"
mib-2.43.11.1.1.6.1.3 = STRING: "Toner Cyan"
mib-2.43.11.1.1.6.1.4 = STRING: "Toner Magenta"
mib-2.43.11.1.1.6.1.5 = STRING: "Toner Gelb"

Status der Toner als Integerwerte (0 = leer, -3 = voll)
mib-2.43.11.1.1.9.1.1 = INTEGER: 0
mib-2.43.11.1.1.9.1.2 = INTEGER: -3
mib-2.43.11.1.1.9.1.3 = INTEGER: -3
mib-2.43.11.1.1.9.1.4 = INTEGER: 0
mib-2.43.11.1.1.9.1.5 = INTEGER: -3

Kommando für Nagios konfigurieren:
define command{
command_name check_toner
command_line /usr/lib/nagios/plugins/check_snmp -H '$HOSTADDRESS$' -C '$ARG1$' -o mib-2.43.11.1.1.9.1.$ARG2$ -w '$ARG3$': -c '$ARG4$':
}

Service für den Host einbinden:
define service {
use generic-service ; Name of service template to use
host_name druckerxyz
service_description TONER YELLOW
check_command check_toner!public!5!2!1
}

Vor kurzem habe ich aufgrund der Catalysts Grant Aktion an die Creative Commons Organisation etwas Geld gespendet. 100.000 $ sollen an Ersteller freier Inhalte gehen. Ich fand das in Ordnung. Ok, ich fand das eigentlich mehr als in Ordnung, denn die Idee des freien Wissens und Inhalten für alle ist einfach nur wunderbar. Es fällt mir schwer in Worte zu fassen was das Video in der About-Beschreibung aussagt. Am besten ihr seht es am besten selbst an.

Inhalte
Seit mittlerweile einem Jahr habe ich alle Blogposts, HowTos, Publications und Projekte die ich hier veröffentliche, schreibe oder vorstelle unter die CC-BY-NC-SA Lizenz gestellt. Im Klartext bedeutet das: Alle Inhalte dürfen komplett frei benutzt, verändert und weitergegeben werden. Unter ein paar winzigen Bedinungen.

CC-BY-NC-SA
Namensnennung
Keine kommerzielle Nutzung der Inhalte
Weitergabe unter gleichen Bedingungen

Software
Bei Software oder Scripts die ich hier schreibe, gilt ähnliches. Die GPL-Software-Lizenz ist weit verbreitet unter Linux-Benutzern und auch hierfür stellt Creative Commons eine Informationsseite in vielen Sprachen zur Verfügung.

CC-GNU-GPL
1. Die Möglichkeit, das Programm für jeden Zweck zu benutzen.
2. Die Möglichkeit, die Funktionalitäten des Programms auf Code-Ebene zu verstehen und sie an Ihre Bedürfnisse anzupassen.
3. Die Möglichkeit, Vervielfältigungen des Programms weiterzuverbreiten, so dass es allen nützt.
4. Die Möglichkeit, das Programm zu verbessern und Ihre Verbesserungen zu veröffentlichen: Auf diese Weise profitieren alle.

Einsatzgebiet?
Wo benutzt man sowas nun. Nunja einfachstes Beispiel wird warscheinlich dieses Blog-Theme sein. Ich habe Clouds von ali asariaerhalten, der das Thought Cloud Theme von Heather Rivers für WordPress portiert hat. Ich durfte es dank Creative Commons weiterentwickeln und (unter Namensnennung) wiederrum (inklusive meiner Änderungen/Anpassungen) unter der selben Lizenz weitergeben. Zumindest werde ich es bald releasen :) Dauert aber noch etwas. Desweiteren bietet auch die Foto-Plattform Flickr eine wunderbare Möglichkeit Fotos unter Creative Commons zu veröffentlichen und vor allem zu finden.

Donation
Aufgrund meiner Spende habe ich heute Post aus San Francisco bekommen :)

In diesem Sinne,
Freie Inhalte ftw.

Die Prozedur ist immer die gleiche. Logfiles untersuchen. Quota ausfindig machen. Mail nachverfolgen. Je nach User individueller Mailserver. Für die grobe Arbeit, hab ich mir jetzt ein kleines Skript geschrieben, mit welchem ich (easy-usage-like ;D) mir ca 5-6 Befehle spare. Ich nannte es mailrequest. Die Kreativität hat mich nämlich einfach überrannt -_-

Das ganze läuft jetzt wie folgt ab.

mailrequest -s stichwort
#Nach Queue-id, Absender, Empfaenger im aktuellen Logfile suchen.

mailrequest -r stichwort
#Für alle Logfiles am Mailserver

mailrequest -q user@foobar.de
#Postfachgroesse ermitteln

Bis dahin hat der Plan ganz gut geklappt. Nur die Auswahl spezieller Mailserver war mir noch nicht schön genug geregelt. Mailserver jedesmal per Parameter mit übergeben müssen? Fand ich zu doof. Aber Hard-Coded im Source ist fast noch ungünstiger gewesen. Den Mittelweg hat mir die Bash ermöglicht.

$host=$3
$defaulthost=mail.domain.de
${host:-$defaulthost}

Klartext: Wenn kein 3. Parameter definiert (oder leer) ist, wird automatisch der $defaulthost gewählt. Sollte der Mailserver nun vom Standard abweichen, kann ich ihn mitgeben. Falls nicht, kann ich mir den 3. Parameter des Aufrufs sparen.

mailrequest -s spam@zwetschge.org mail.zwetschge.org

Das ganze Script zum begutachten, Kritik äußern, anflamen, besserwissen: http://zwetschge.org/paste/013

Um es wie der Typ aus der Congstar-Werbung zu sagen: “I like”.

Sandspeeder with Sand Scout
Ursprünglich hochgeladen von Avanaut

Kind of testing flickr’s “blogg!”-function.
love this <3

Aufgrund einer bereits getätigten Bestellung von Fotos bei www.pixaco.de, beschloss ich also mein Glück dort zu versuchen. Musste aber feststellen, dass pixaco.de von HP aufgekauft wurde und jetzt Snapfish (www.snapfish.de) heisst. Qualitäts-, Service-, Lieferdauer-mäßig war alles gut gewesen und mein Account bestand noch, warum also nicht.

Ich muss sagen, dass ich im Allgemeinen sehr sehr postiv von dem ganzen Vorgang überrascht war. Einloggen, auf Fotobuch drücken und OS auswählen:
(Bilder verkleinert angehängt, mit Orginalgröße verlinkt)

Linux Kernel 2.6, glibc 2.6. Muss ich zugeben, hört sich etwas abschreckend an. Ganz im Gegenteil verlief die Installation allerdings. Bei Auswahl des Radio-Buttons “Linux” , bekommt man vom Webserver seitens Snapfishs ein gut geschriebenes (soweit ich das mit meinem unterentwickelten Kenntnissen beurteilen kann) Perl-Skript zugeschoben, welches man einfach auszuführen hat.

Sehr einfach, sehr schön, wenn ich mir überlege, dass das Software eines Drittanbieters ist, die nicht aus den Repos kommt. Und (warscheinlich) noch dazu “unfrei” ist. Jedenfalls, der Installtionsprozess ist nicht das einzige schöne daran. Auch die Software an sich läuft stabil, sieht gut aus und ist einfach zu benutzen.

Auch Installation zusätzlicher Verzierungen oder sonstigem innerhalb der Software funktioniert wunderbar. Nach ca 4-5 Werktagen (von denen ich den Großteil damit verbracht habe das Buch überhaupt zu erstellen :D )  kam dann die Lieferung von Snapfish. Wie bereits erwähnt, wunderbare Qualität, schnell, schön. Finde es dabei auch awesome, dass alternative OS bei Entwicklung solcher, ich sag mal, kommerziellen Programme nicht zu kurz kommen. Danke pixaco, Snapfish oder HP. Wie auch immer du dich jetzt nennen magst. Ich muss allerdings dazusagen, dass ich nicht weiss, was andere Anbieter in dem Bereich parat haben. Snapfish war jetzt sozusagen mein Glückstreffer und ich musste mich gar nicht wirklich gross erkundigen wo man mit Linux soetwas machen lässt/erstellen kann. Jedenfalls, meine dickste Empfehlung an Snapfish.

mspr0.de, wessen Gedankengang ich sehr interessant finde und sich über das möglicherweise Werbung ersetztende System ausschüttet.

Von Jan (virtualpixel.de)der, wie viele andere, dass Konzept sehr mag und seinen Blog in Flattr integriert hat (oder umgekehrt?). Was ich auch verstehe weil viel zu viel guter Content viel zu wenig gefördert wird.

Von blog.fefe.de der Aufgrund des Datenschutzes seiner Leser auf diesen Service verzichten möchte. Auch diesen Ansatz kann ich sehr nachvollziehen und ist meiner Meinung auch der größte negativ Punkt innerhalb der Story.

Auch Nico Hofmann hat treffend (wenn auch etwas unernst) getwittert:
Wann #flattr wohl die AGB-Änderung mit der Abtretung der Rechte am Content bekannt gibt?

Im Großen und Ganzen würde ich vielen Bloggern gerne etwas Kleingeld für ihre Bemühungen und sehr tollen Artikel zuschanzen. Aber ich bin mir nicht sicher ob Flattr der richtige Weg dafür ist. Aus eben genau den Gründen, die Skeptiker anprangern.

Immernoch habe ich die InviteCodes für Flattr in meinem Postfach liegen, aber es noch nicht geschafft mich dort wirklich mal anzumelden.

Vorerst werde ich in Untätigkeit verweilen und ohne Werbung, Datenerhebung und Donation-System meinen Blog weiterführen. Denn gestartet habe ich ihn nur aus Gründen der Eigendokumentation. Und wer würde für diesen Blog schon Geld hergeben? ;)

Vielleicht wäre ich dafür eher ein Kandidat. Kathrin Passigs Gegenprojekt

Nun der Single-Point-of-Failure (oder auch Arbeits-PC) der 24 Std in Betrieb ist und Mails sortiert, hängt sich ständig auf, stürzt ab oder ignoriert willkürlich Filter. Gerade als ich 4 Wochen nicht in der Arbeit und teils auch in den USA war, war es sehr ungünstig nach 3 Tagen festzustellen das im Posteingang 600 unsortierte Mails liegen. Ein Umstieg stand an. Habe mich für Evolution entschieden und fand das auch im ersten Moment sehr sehr schön gemacht. Es gibt nur einen riesen Nachteil. Es ist nicht möglich, dass eintreffende Mails automatisch sortiert werden.

Auch der Lösungsansatz von http://ubuntuforums.org/showthread.php?t=99930 konnte mir nicht helfen.

Jedesmal STRG + Y zu drücken kommt absolut nicht in Frage. Das funktioniert auch nicht, da ich nicht rund um die Uhr in der Arbeit bin. Später habe ich versucht dieses Event irgendwie über CronJob aus dem Source-Code starten zu lassen. Ohne Erfolg.

Ich muss wirklich sagen, schöne Arbeit Evolution. Würde dieses tolle Mailprogramm auch sehr gerne weiterhin benutzen. Aber unter diesen Umständen auf keinen Fall. Schade, dass wirklich schöne Software immer an irgendwelchen Kleinigkeiten scheitern. Was keinen Vorwurf gegenüber der Software selbst darstellt. Eher ein kleines Makel was für einzelne User wichtig wäre. So bin ich nun zu Thunderbird 3.0 migriert und liege Nachts wach, aus Angst morgens von Mails überrollt zu werden ;)

# 1
let i+=1 # increment
let i-=1 # decrement

# 2
let i++ # increment
let i-- # decrement

# 3
i=$[$i+1] # increment
i=$[$i-1] # decrement

# 4
i=$((i+1)) # increment
i=$((i-1)) # decrement

# 5
((i++)) # increment
((i--)) # decrement

# 6
i=$(expr $i + 1) # increment
i=$(expr $i - 1) # decrement

# 7
: $[ n = $n + 1 ] # increment
: $[ n = $n - 1 ] # decrement

Das waren so die üblichen Varianten mit denen ich mir die letzten Monate geholfen habe. Mitunter wirklich unschöne Sachen. Auf http://tldp.org/LDP/abs/html/declareref.html bin ich dann allerdings auf eine sehr elegante Lösung gestossen. Via “declare” lässt sich eine Variable auf einem bestimmten Typ festnageln. “declare -i VAR” deklariert (haha) die Variable “VAR” nach Integer. So lässt sich quasi direkt damit rechnen. Anschliessend das Beispiel um im Bild zu bleiben:

# Declare Variante
declare -i i # -i = integer
i=$i+1 # increment
i=$i-1 # decrement

Das geht wiederrum auch mit mehreren Variablen, Zahlen und Rechenoperationen. Ein kleines einzeiliges Beispiel:

j=5 ; k=12 ; declare -i i ; i=$j*10+$k/2 ; echo $i

Natürlich gibt es auch noch andere lustige Modi die man seiner Variable aufs Auge drücken kann:

declare -r # readonly
declare -a # array
declare -x # export variable
declare -f # function

Alles in Allem sehr nett. Werde jetzt erstmal ein paar Skripte umbauen. Denke ich.

Aufgabenstellung: Erstelle ein Skript “rechner”, welches 2 Parameter aufnimmt und über Abfrage innerhalb des Skriptes den Modus auswählbar macht. Folgende Modi und Funktionen müssen enthalten sein:

Modus 1: Multiplikation
Usage: ./rechner 1  2
Ausgabe: Das Ergebnis von 1 * 2 = 2

Modus 2: Counter
Usage: ./rechner 2 8
Ausgabe : 2-3-4-5-6-7-8

Formatierung muss genau der Vorgabe entsprechen. Außerdem darf der erste Parameter nicht größer als der Zweite sein und falsche Modi-Angabe mit Fehler gemeldet werden.

Ich muss für meinen Teil ganz ehrlich sagen, dass das wohl ein noch viel unsinnigeres Programm ist. Wenn ich auch glaube, dass es einfach nur um die Erfüllung bestimmter Umstände geht. Der Rest ist anscheinend ziemilch egal.

Gelöst habe ich das ganze wie folgt:

    #!/bin/bash
    i=$1
    if [ $1 -gt $2 ]; then echo "Falscheingabe" ;  exit 200; fi

    echo "Multiplikation = 1"
    echo "Einserschritte = 2"
    echo -n "Modus eingeben:" ; read modus

    if [ $modus -eq 1 ] ; then
            echo -n "Die Multiplikation aus $1 * $2 = "; expr $1 \* $2
    elif [ $modus -eq 2 ] ; then
            while [ $i -lt $2 ] ; do
            echo -n  "$i-"
            i=$[$i+1]
            done
            echo "$2"
    else
            echo "Falscheingabe"
    fi

Und wie von @nicohofmann prophezeit: Die 1 ;)

#!/bin/bash

Morgen wird es einen Test geben, bei dem wir innerhalb 30 Minuten eine bestimmte Aufgabe scripten sollen und als “Abgabe” sozusagen vorführen müssen.

Eine Vorbereitung für diesen Test lautete wie folgt:

Schreibe ein Script, welches durch Angabe von Parametern in verschiedenen Zeitintervallen und maximaler Ausführdauer das aktuelle Datum und die Uhrzeit ausgibt. Außerdem soll zwischen 2 Modi gewechselt werden können. Mit vorangestelltem Text “Uhrzeit ist:” und nur die Uhrzeit.

Usage Beispiel:
./zeitausgabe 2 10 modus

Naja. Bevor wieder diverse Trolle in den Kommentaren ihrem Ruf gerecht werden: Die Klasse ist bis auf einen %-Anteil von ca 5 komplett Windows-User und haben Bash-Scripting seit ca 7 Schultagen unterrichtet bekommen. In dieser Dimension wird also auch der Test Morgen ausfallen. Ich bin gespannt.

Meine Lösung der Aufgabe:

#!/bin/bash
    interval=$1
    gesamtdauer=$2
    modus=$3
    count=0

    if [ "$modus" = "txt" ]; then
            while [ $count -lt $gesamtdauer ]; do
            let count+=$interval
            sleep $interval ; echo "Das ist die Systemzeit: $(date)"
            done
    else
            while [ $count -lt $gesamtdauer ]; do
            let count+=$interval
            sleep $interval ; echo $(date)
            done
    fi

Relativ simpel via
fsck -y /dev/ida/c0d01p

Zum Schluss noch bisschen was auf die Augen :)

Ich und so.

IE8 Fehlermeldung am TimesSquare

Empire State Building

Man merkt bestimmt, dass mich Git im Moment sehr fasziniert. Es ist eine Mischung aus “Wow, ist das umfangreich” und “Ah Dokumentation ist alles”. Mittlerweile habe ich die verschiedensten Projekte in meinen Git-Server ausgelagert. Sogar meine Tiddlywiki hab ich aufgelöst und als Git-Repo umgesetzt.

Ich las jedenfalls viel in www.progit.org. Progit ist übrigens auch ein sehr schönes Projekt. Es stellt eine Dokumentation für alle Sprachen über Git dar. Diese Dokumentation ist auf Github für jeden forkbar und jeder kann theoretisch daran mitwirken.

Ich schweife schon wieder ab. In Progit findet man eine wundervolle Beschreibung wie man in Git einzelne Workflows bzw Branches verwaltet und wie man am effektivsten mit ihnen arbeitet. Angenommen ich habe bereits in einem bestehenden Projekt ca. 5 Commits und möchte aber vom Inital-commit noch einmal anfangen, um in eine andere Richtung weiterzuentwickeln.

            Master
            |
o--o--o--o--o

Sieht das ca so aus. Es besteht nun die Möglichkeit (und das ist der Grund warum ich diesen Post hier verfasse) eine neue “Entwicklungssparte” aka Branch zu starten und auf Anfang zu setzen.

Initial     Master
|           |
o--o--o--o--o

# Neuen Branch erstellen namens inital
git branch initial

# Branches anzeigen
git branch -a -v
* master                 0bfb896 removed r_error() and added some comments
remotes/origin/HEAD    -> origin/master
remotes/origin/initial d6600f1 First inital commit
remotes/origin/master  0bfb896 removed r_error() and added some comments

# Branche initial auf spezielle Commitnummer setzen
echo "d6600f10479bb2d0d69aa8086ebe4e3149d4ef76" >> roborobo.git/.git/refs/heads/initial

# In den neu erstellten Branch wechseln
git checkout initial

# Via git log kontrollieren
git log

# neuen Branch zum Server pushen
git push origin initial

Weiterhin angenommen ich entwickle in der neuen Spalte “initial” weiter und commite das wiederrum dürfte das bild so aussehen:

Initial
   |
o--o        Master
|           |
o--o--o--o--o

<3 Git.

Man darf sich (for free) ein Shirt aussuchen, wenn in dem eigenen Blog (der den Erwartungen entsprechen soll) ein kleiner nett gemeinter Blogpost auftaucht, der auf die Aktion hinweist. Finde ich sehr nett muss ich sagen ;) Alle Infos zur Shirt4Link Aktion hier: http://www.3dsupply.de/shirt4link/

Aufgrund meiner Neigung zu Futurama musste es natürlich folgendes werden:

dankend,
Flo

$ git clone git://zwetschge.org/roborobo.git

lässt sich über den Daemon ein Repo auschecken. Der Logeintrag bei Access sieht folgendermaßen aus:

2010-04-20_11:37:52.05907 [16810] Connection from 200.200.200.200:54283

Nun lässt sich über ein einfaches Script, beispielsweise:

$ for i in $(seq 1 100) ; do git clone git://zwetschge.org/roborobo.git gitrepodos$i ; done

den Server total auslasten. Gerade bei grossen Repos wäre das fatal.
Über RegExp und fail2ban-regexp lässt sich der Ausdruck im Logfile auch filtern und testen:

fail2ban-regex '2010-04-20_19:52:01.41131 [26818] Connection from 200.200.200.200:54283' '.*Connection from <HOST>:.{4,5}$'

gibt zurück der Ausdruck würde matchen. Meine Filterregel sieht auch dementsprechend aus:

failregex = .*Connection from <HOST>:.{4,5}$

und der Eintrag in der jail.local (damit als jail erkannt wird):

[git-daemon]
enabled  = true
port     = git
filter   = git-daemon
logpath  = /var/log/git-daemon/current
maxretry = 5

ist eingerichtet. Keine Fehler im Fail2ban-Log. Alles erfolgreich gestartet. Aber der Filter matched einfach nicht wenn ich das Script ausprobiere.

Statusabfrage des Jails:

$ fail2ban-client status git-daemon

Status for the jail: git-daemon
|- filter
|  |- File list:    /var/log/git-daemon/current
|  |- Currently failed:    0
|  `- Total failed:    0
`- action
|- Currently banned:    0
|  `- IP list:
`- Total banned:    0

Ich weiss mir gerade nicht zu helfen. Obwohl ich das selbe Spiel mit vsftp auch gemacht habe. LINK

git clone git://zwetschge.org/roborobo.git

Befehl in gitweb hinterlege. Das fand ich sehr hilfreich, denn seit ich meinen git-daemon wieder installiert habe, wäre es theoretisch möglich die PublicProjects darüber auszuchecken. Damit gitweb nun diese URL kennt, ist es nötig in dem Remote-Verzeichnis die Datei cloneurl anlegen. Kurz und prägnant damit ich es nicht wieder vergesse:

echo "git://zwetschge.org/roborobo.git" > /home/git/public/roborobo.git/.git/cloneurl

Dieses File liesst gitweb dann aus und schreibt die URL (in meinem Falle für roborobo) in die Summary-Übersicht mit rein.

Beispiel: http://git.zwetschge.org/?p=roborobo.git;a=summary

Heute wollte ein Kunde mit etwas mehr Domains wissen, welche verschiedenen TLDs genau dabei sind. Hatte auch kostentechnische Gründe. Jedenfalls wollte ich nach dem exportieren nicht wirklich die Liste durchgehen und rausschreiben.

Wie beschreibe ich also Domains in Regular Expressions?

^.*\.(.*)
Würde das Format beschreiben. Im Grunde alles was nach dem ersten Punkt einer Zeile kommt in $1 ablegen (durch () markiert). Kämen keinen doppelten Domains wie .co.uk in die Quere und Subdomains kommen nicht aus der Domainliste. Ziemlich low-level-regexp.

cat KundenDomainliste.txt | sed -e 's/^.*\.\(.*\)/\1/'
Gibt die komplette Domainliste (nur mit TLDs) aus. Sonderzeichen wie ( ) müssen für die Bash noch escaped werden. Desweiteren noch den Ausdruck auf den die Beschreibung zutrifft durch 1 ersetzen. Wurden aber nicht weniger Domains.

cat KundenDomainliste.txt | sed -e 's/^.*\.\(.*\)/\1/' | uniq | sort
Die Ausgabe von sed an uniq zu übergeben, behebt diesen Umstand. Um noch alphabetisch zu sortieren diese Ausgabe wiederrum an sort übergeben. Nett.

Raus kommt eine Liste von Domainendungen:
.au
.co.uk
.com
.de
.hu
.it
usw…
Übrigens bin ich mir der Ironie bewusst, cat zu benutzen. Useless use of cat

Vor ein paar Wochen habe ich dann angefangen mir ein kleines Helferlein zu coden. Anfangs war dieses Helferlein nur für mich gedacht und demnach relativ speziell. Ich nannte ihn “roborobo”.

Was er tut ? Ich gebe meinem Helfer einfach das File “in die Hand”. Alles andere erledigt er.

File hinzufügen
$ roborobo /etc/postfix/main.cf

Alle bekannten Files updaten:
$ roborobo

Er nimmt das File an, ordnet es ein und sichert es in seinem Verzeichnis mit dem kompletten Verzeichnispfad nach Baumstruktur-Art. Außerdem prüft roborobo jetzt jede Stunde anhand der sha1sum ob sich in dem File seit der letzten Prüfung etwas getan hat. Falls Veränderungen da sind, wird das File mit neuem Datum wieder abgespeichert. Das sieht ungefähr so aus:

.roborobo/
|-- etc
|   |-- hosts
|   |   |-- hosts-20100409-1348
|   |   `-- hosts-20100409-1651
|   `-- network
|       `-- interfaces
|           |-- interfaces-20100409-1654
|           `-- interfaces-20100409-1655

Ich brauche mich somit um _nichts_ mehr kümmern. Gebe dem “kleinen” die Files die mir wichtig sind und er passt darauf auf. Fühlt sich irgendwie an wie ein Backup-Daemon ;)

Jedenfalls, habe ich roborobo jetzt für den Einsatz auf jedem beliebigen System umgebaut und in ein Debianpaket gebastelt. Dokumentation erstellt, Config-Dateien ausreichend selbsterklärend gestaltet usw.

Wer sich dafür interessiert oder mal testen mag:

roborobo-Debianpaket bei Github
roborobo-Projekt auf Github
Alles nochmal bei meinem privaten Git-Server auf git.zwetschge.org

Content:

roborobo
|-- DEBIAN
|   `-- control
|-- etc
|   |-- cron.d
|   |   `-- roborobo
|   `-- roborobo
|       |-- roborobo.conf
|       `-- roborobo.path
`-- usr
    |-- bin
    |   `-- roborobo
    `-- share
        |-- doc
        |   `-- roborobo
        |       |-- changelog
        |       `-- copyright
        `-- man
            `-- man1
                `-- roborobo.1

Das ganze wie alles was ich tue, unter GPLv3. Viel Spass damit ;)

Umständlich aber trotzdem zielführend. Die single.php stellt die Einzelansicht eines Blogposts. Super das will ich ja. Die Archiv-Template-Seite kann man in dem Theme-Dir ruhig liegen lassen:

cd /var/www/blog/wp-contents/themes/clouds/
cp single.php archive.php

Darauf folgend habe ich die Post-Aufrufe aus dem Quelltext entfernt. Der Source ist relativ selbsterklärend. Somit besteht nur noch das Grundgerüst einer Einzelansicht. Wo sich vorher die Aufrufe für die Posts befand, fügte ich folgendes ein:

<br/><b>Monthly outline</b>
<?php wp_get_archives('type=monthly&show_post_count=1'); ?>
<br/><b>Post outline by date</b>
<?php wp_get_archives('type=postbypost');?>

Die Funktion wp_get_archives ist allerdings sehr schön dokumentiert. Die Kunst an dem eigentlich Spass war aber das einbinden dieser archive.php-Datei.

Damit WordPress erkennt, dass es sich bei archive.php um eine Template-Datei handelt:

<?php
/**
* @package WordPress
* @subpackage Default_Theme
*/
/*
Template Name: Archives
*/
?>

am Anfang der Datei einfügen. Jetzt noch in WordPress die Seite erstellen. Dazu musste ich eine Seite anlegen mit leerem Inhalt. Anschliessend bei Seiten -> bearbeiten -> Quickedit(!) -> Template: Archive auswählen.

Ich teile mir in meiner Funktion als Auszubildender mit einem Kollegen die ehrenvolle Aufgabe, ab und an den Papierstand unserer 4-Fächer Ricoh Drucker bei Gelegenheit zu “überwachen”. Im vorbeigehen sozusagen. Nun, das ganze ist ein etwas undankbarer Job – denn egal wie oft man zum Kontrollieren kommt – es kommt immer der Moment in dem nichts mehr im Fach / den Fächern ist, wenn Kollegen 200 Seiten am Stück ausdrucken.

Um an diesem Umstand etwas zu ändern kam uns neulich eine “Notification”-Idee. In der Beschreibung des Druckers steht “SNMP-fähig”. Das Simple Network Management Protokoll bietet allerlei Möglichkeiten Informationen von Routern, Switches, Server oder Desktoprechnern abzufragen. In unserem Fall bietet auch der Drucker diese Möglichkeiten. Nach kurzer Recherche, scheint es etwas wie OIDs / MIBs für Drucker zu geben. Eine Liste dieser OIDs lässt sich mit snmpwalk ausgeben.

snmpwalk -Os -c public -v 1 192.168.1.200

Herauskommt eine _Menge_ an Informationen, mit der man erst mal umzugehen wissen muss. Nach etwas suchen, fiel mir folgender Block ins Auge:

mib-2.43.8.2.1.10.1.1 = INTEGER: 55
mib-2.43.8.2.1.10.1.2 = INTEGER: 385
mib-2.43.8.2.1.10.1.3 = INTEGER: 55
mib-2.43.8.2.1.10.1.4 = INTEGER: 385
mib-2.43.8.2.1.10.1.5 = INTEGER: 0
mib-2.43.8.2.1.11.1.1 = INTEGER: 0
mib-2.43.8.2.1.11.1.2 = INTEGER: 0
mib-2.43.8.2.1.11.1.3 = INTEGER: 0
mib-2.43.8.2.1.11.1.4 = INTEGER: 0
mib-2.43.8.2.1.11.1.5 = INTEGER: 9
mib-2.43.8.2.1.12.1.1 = ""
mib-2.43.8.2.1.12.1.2 = STRING: "Briefbogen"
mib-2.43.8.2.1.12.1.3 = ""
mib-2.43.8.2.1.12.1.4 = ""
mib-2.43.8.2.1.12.1.5 = ""
mib-2.43.8.2.1.13.1.1 = STRING: "Tray 1"
mib-2.43.8.2.1.13.1.2 = STRING: "Tray 2"
mib-2.43.8.2.1.13.1.3 = STRING: "Tray 3"
mib-2.43.8.2.1.13.1.4 = STRING: "Tray 4"

Kurzes systematisches Trial-and-Error am Papierfach des Druckers und Kontrolle der Veränderungen der SNMP-Ausgabe brachten mehr Aufschluss. Es schien also so als würde ein Teil der SNMP-Ausgabe die geschätzten Werte an Papier im Drucker zurückliefern.

Genau genommen die OIDs :
mib-2.43.8.2.1.10.1.1
mib-2.43.8.2.1.10.1.2
mib-2.43.8.2.1.10.1.3
mib-2.43.8.2.1.10.1.4

Damit lässt sich arbeiten. Für jedes Papierfach des Druckers eine OID-Nummer. snmpget lässt ein Gerät explizit nach einer OID fragen, oder ihren Descriptor.

snmpget -v1 -Cf -c public 192.168.1.200 mib-2.43.8.2.1.10.1.1
SNMPv2-SMI::mib-2.43.8.2.1.10.1.1 = INTEGER: 385

Im ersten Fach sind also 385 Blätter. Schätzungsweise. So ist es also möglich den aktuellen Stand der Papierfächer abzufragen, ohne aufstehen zu müssen. Das war schonmal was. Aber wie das jetzt mit Benachrichtigung laufen lassen? CronJob? Nagios! Wo sonst httpd’s, smb-Freigaben, Erreichbarkeiten oder sonstige Dienste abgefragt und monitored werden, ließen sich auch die Papierfächer einbinden.

Zuerst die Drucker als Hosts einbinden, die Nagios überwachen soll:

/etc/nagios3/conf.d/host-printer1.intern.cfg
define host {
        host_name  printer1.intern.firma.de
        alias       printer1
        address     192.168.1.200
        use         generic-host
        }

Jetzt kennt Nagios den Host. Weiss aber weder was dort überwacht werden soll, noch mit welchem Plugin und ab welchem Schwellwert es Alarm schlagen soll. Nagios enthält ein Plugin für SNMP-Abfragen. Zu finden unter /usr/lib/nagios/plugins/check_snmp. Diesem Plugin kann ich die selben Fragen stellen wie mit snmpget. Einzige Veränderung: Schwellwerte für Warning (-w) und Critical (-c) müssen mitgegeben werden. Ich erstellte also einen sogenannten “Check”.

/etc/nagios3/conf.d/z_check_papertray:
define command{
         command_name    check_papertray
         command_line    /usr/lib/nagios/plugins/check_snmp -H '$HOSTADDRESS$' -C '$ARG1$' -o mib-2.43.8.2.1.10.1.$ARG2$ -w '$ARG3$': -c '$ARG4$':
}

Die -H Hostadresse wird aus der angegebenen Adresse im Hostfile gewonnen in dem der Check später als “Service” eingebunden wird. Außerdem noch jede Menge Argumente die auf den ersten Blick vielleicht verwirren.

Argument1: Community für die SNMP-Anfrage. In dem Fall “public”
Argument2: Fachnummer mit der die OID ergänzt wird.
Argument3: Warning-Wert bei dem Nagios Alarm schlägt.
Argument4: Critical-Wert bei dem Nagios Alarm schlägt.

In der Hostdatei kann der definierte Check jetzt als Service eingebunden werden.

define service {
        use                             generic-service
        host_name                      printer1.intern.firma.de
        service_description             PAPERTRAY 1 DinA4
        check_command                   check_papertray!public!1!150!56
        }

Das ganze 4 mal. Für jedes Papierfach einmal. check_command ist dabei der ausschlaggebende Punkt. Nagios zieht aus jedem Wert nach ! seine Argumente. Community public, Fach 1, Schwellwert Warning 150 und Critical 56 oder kleiner.

Wenn dann alles funktioniert, sieht das aus wie folgt:

Und im Falle eines Falles. Emails:

** PROBLEM Service Alert 2: printer1/PAPERTRAY 1 DinA4 is CRITICAL **

***** Nagios *****
Notification Type: PROBLEM
Service: PAPERTRAY 1 DinA4
Host: printer1
Address: 

192.168.1.200

State: CRITICAL
Date/Time: Thu Apr 1 16:30:42 CEST 2010
ACK by:
Comment:
Additional Info:
SNMP CRITICAL - *0*

Schön, denn wir werden jetzt immer benachrichtigt wenn kein Papier mehr im Fach ist, oder es bereits aufgefüllt wurde. Und Chef fands auch gut :)

Nachdem mein Apache immer mehr und mehr virtuelle Hosts / eingerichtete Subdomains bekommt, welche alle in das /var/log/apache2/access.log reinloggen, fand ich es an der Zeit etwas mehr Struktur rein zu bringen. Generell werden alle bestehenden vhosts in /etc/apache2/sites-available/* deklariert.
Darin befinden sich allerlei Deklarationen wie der Ort des Directory und ähnliches. Kurzer Head-Auszug:

ServerAdmin webmaster@zwetschge.org
ServerName noqqe.de
ServerAlias www.noqqe.de
DocumentRoot /var/www/blog/

Unter anderem auch die Anweisung für logging:

LogLevel warn
CustomLog /var/log/apache2/access.log combined

Alle meine vhosts haben den selben Eintrag und loggen demnach auch alle in das selbe File. Dieser Umstand wird relativ schnell zum Problem. Ständiges greppen und ähnliches an der Tagesordnung. Apache ist aber eben auch in der Lage für jeden vhost eine extra Logfile zu generieren.

LogLevel warn
ErrorLog /var/log/apache2/noqqe.de-error.log
CustomLog /var/log/apache2/noqqe.de-access.log common

Mit der Syntax [$domain]-[access|error].log ist es im Apachenlogverzeichnis schön außeinander zu halten auf welchen vhost welche Anfragen gingen. Erleichtert die Suche ungemein. Auch Aufgliederung in apache2/error/* und apache2/access/* wäre denkbar. Aber für mich gerade oversized.

Nächster Punkt auf der Liste: logrotate

Ein Logfile wird _rotiert_. Diese Rotation übernimmt das Programm Logrotate. Jeder kennts:

-rw-r----- 1 root adm 360K 29. Mär 00:25 access.log.1
-rw-r----- 1 root adm 193K 31. Jan 00:25 access.log.10.gz
-rw-r----- 1 root adm 192K 24. Jan 00:25 access.log.11.gz

Ich möchte auch gerne meine vhost-Logfiles rotieren lassen. Wie in jedem (guten) Daemon gibt es auch hier ein Verzeichnis logrotate.d/*. Darin befinden sich manuell angepasste config-Files die zb bei Upgrades nicht überschrieben werden. Der folgende Eintrag lässt alle Dateien die mit .log enden und sich im Verzeichnis /var/log/apache2/ befinden wöchentlich bis zu 10 Wochen rotieren und komprimieren:

/var/log/apache2/*.log {
        weekly
        missingok
        rotate 10
        compress
        delaycompress
        notifempty
        create 640 root adm
        sharedscripts
        postrotate
                if [ -f "`. /etc/apache2/envvars ; echo ${APACHE_PID_FILE:-/var/run/apache2.pid}`" ]; then
                        /etc/init.d/apache2 reload > /dev/null
                fi
        endscript
}

~/Library/Application Support/Adium 2.0/
~/Library/Preferences/com.adiumX.adiumX.plist

weg kopieren und nach der neuen Installation wieder einspielen. Und die Pfade für solche Späße bei Mac OS X gefallen mir immernoch nicht. Was soll man machen.