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

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

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.

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.

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 :)

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

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

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

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.

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.

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 ;)

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.

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.

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.

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"

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.

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.

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 :)

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. :)

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”.

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

#!/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

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.

~/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.

Ein Stück weit, darf hier ruhig auch etwas Privates einziehen. Am Sonntag 14. März war ich zum ersten Mal zu Besuch bei den Chemnitzer Linuxtagen. Die knappen 2 Stunden mit dem Auto habe ich morgens um halb 8 auf mich genommen :) Ich muss sagen ich war relativ begeistert.

Nach der Ankunft, sah ich mich erst etwas in der Halle um, besuchte Jan am Debian-Stand und liess mich erstmal von durchweg freundlichen Projektvertretern in ihr (mir meistens bereits bekanntes) Projekt einführen.

Darauf folgte eigentlich ein Marathon aus Vorträgen. Durch einen Umstand konnte ich mich leider nur Sonntags den Vorträgen unterziehen. Aber trotzdem gefielen mir die, die ich sah, sehr gut.

1. Anonymität im Internet (TOR, i2P und grundsätzliches zu Daten)
2. Virtual System Cluster mit KVM und Pacemaker (B1-Systems. Für mich teils interessant für Arbeit. Thema Virtualisierung)
- Mittagspause-
3. Auf dem Weg zum Intrusion Detection System der nächsten Generation (IDS war ein bisschen Unglücklich gewählt. Sehr theoretisch im Bezug auf Social Engineering)#
4. MySQL Backups – Best Practices (Ein Referent mit polnischer Herkunft klärte mich über grösstenteils alle Backuplösungen auf. Hot / Cold / Txt / Binary / Differentiell)
5. Computerviren und Linux (Sehr sehr nice gewesen. Haufen neue Erkenntnisse gehabt)

Im generellen auch netten Kontakt mit den unterschiedlichsten Linux-Anwendern gehabt. Linux@Grundschule Linux@HP und ähnliches.
Werd ich nächstes Jahr gerne wieder besuchen. Vielleicht sogar das ganze WE.

JESS3 / The State of The Internet from JESS3 on Vimeo.

Awesome gemacht.

Hallo flo (oder noqqe oder wie?)
auch ich möchte mehrere teeworlds server auf einem Rechner laufen lassen.
Ich komme mit Linux ganz gut klar, habe aber von teeworlds bisher keine Ahnung.

Kannst du mir deinen Verzeichnisbaum mit den verschiedenen Configfiles als tarball
zusammenpacken und zuschicken?

Unter http://noqqe.de/?p=800 hast du eine Kurzanleitung geschrieben, aus der ich bestimmt schlau würde,
wenn ich mich mit teeworlds auskennen würde. Hast du das noch etwas kleinschrittiger?

Ich wäre dir sehr dankbar (und rund 200 Oberstufenschüler auch, da die Server innerhalb einer Schule laufen werden !!!)

Gruß aus

Haan (Rheinland)
R. S.

Fand ich nett. Fand ich aber auch wunderlich. G8 Schüler haben anscheinend doch noch zu viel Zeit ;) Wenn ich weiss wie es geworden ist werd ichs hier verlauten lassen.

Das war sonst anders. Etwas perplex startete ich Xubuntu, Pidgin und die aktuelle libpurple geprüft. Funktioniert nicht. Aus den hintersten Ecken meiner Wohnung kramte ich einen PC hervor von dem ich wusste er würde ein kommerzielles OS aus Redmond enthalten. Als ich ihn einschaltete wusste ich wieder warum er dort stand woher ich ihn geborgen hatte.

Gefühlte 3 Stunden und 5 BlueScreens später beantwortete ich die Huhn oder Ei Frage am Ende der Installation von ICQ souverän. Die Antwort die ich gab ist mir gerade entfallen. Auch der orginale ICQ Client sollte mich wieder enttäuschen. Aber mir fiel ein Feld mit der Beschriftung “Lost your Password?” auf. Nachdem ich also erneut einige Zeit abwartete (um zu viele fehlerhafte Loginversuche ausschliessen zu können) überschrieb ich mein mittlerweile 6 Jahre altes ICQ Passwort. Ich gebe in aller Schande zu, dass das Passwort mein erstes war. Ich hatte es einfach nie geändert, vergessen, verdrängt. Zusätzlich war es aus meiner Profilbeschreibung abzuleiten, aber mit 14 Jahren hatte ich noch anderes im Kopf als Brute-Force-Attacken, Passwort-Algorithmen (wie ich sie mittlerweile habe) und Sicherheit.

Es wunderte mich extrem wie sich das Passwort ändern konnte. Ich saß an 3 verschiedenen PCs / Clients  über einen Zeitraum von 3 Stunden um in mein ICQ einloggen zu können. Die Maschinen in denen ich mein Passwort für den besagten Messaging-Dienst anvertraute werden es doch wohl nicht vergessen haben? War das wirklich “gehacked” oder “geBrute-Forced”?

Ich wüsste nicht warum.  Jedenfalls, liess sich das ICQ-Passwort über Eingabe der damals hinterlegten Emailadresse resetten. Ich gab einer Hand voll Archäologen den Auftrag dieses Postfach für mich ausfindig zu machen. So in etwa.

Dies ist eine wahre Geschichte und ich bin (wieder) online.

Gerade machte ich mir Gedanken, bzw wurde dazu gezwungen Schrägstrich verleitet mir Gedanken zu machen über Twitter. Vielleicht liegt das an den mehr oder minder folgenswerten Leuten denen ich folge bzw jetzt nichtmehr folge, dass ich Twitter manchmal nervend finde. Warum setz ich mich noch gleich vor den PC ? Achja stimmt, ich wollte _nicht_ wissen was gerade im Fernsehen läuft. Oder so.

Na gut ich schweife ab. In meiner Twitter-Timeline fand ich jedenfalls so einige Tags die da hiessen #sdr, #bsf oder ähnliches, die mich in erster Linie an Rundfunksender oder Viehkrankheiten erinnerten. Wie sich kurzerhand herrausstellte sollte das garnicht so weit von dem entfernt sein was ich dachte. Kommentare zu Bauer sucht Frau oder Schlag den All-in-One-Moderator von Prosieben.

Ich fragte mich ob ich meine Timeline auch ohne diese Tweets lesen könnte. Ein grep -v $HASHTAG sozusagen. Dies schrob ich (ja schrob ist auch ein schönes Wort, genauso wie fotofiert) dann in Twitter. Ich schweifte von hier nach da, von Automatisierungmöglichkeit zum Melitta Filter für Twitter. Über Interessen, Langeweile, Stumpfsinn, oder ob ich der einzige bin den sowas _nicht_ interessiert.

Warum gäbe es keine automatisierte Filtermethode für TV-Serien die mich nicht intressieren? Warum gäbe es keine automatisierte Filtermethode für Tweets die mich allgemein nicht interessieren? Ein Melitta-Beutel an dem die ganzen Tags hängen bleiben die ich nicht lesen will. Andererseits. Warum sollte ich meine Timeline bei Twitter dann überhaupt noch aktualisieren? Alle 2 Wochen würden dann warscheinlich reichen… Auch auf die Gefahr hin das ich meine eigenen Tweets warschenlich nichtmehr lesen könnte…

Bis Benne mir einen Tweet mit dem Inhalt:

@noqqe man sollte die ganzen tags mal sammeln ;-)

zusandte, welcher meine Denke dann in Richtung Adblockplus brachte.
Es wäre doch awesome eine Art, naja. Eine Art ja Adblock zu haben. Ein Plugin für Twitter die automatisch Tweets je nach Hashtag blocken, man allerdings Abonnementen-Like den Filterlisten von Leuten subscriben könnte.

Klar das wäre Aufwand für denjenigen der diese Liste pflegt. Aber Adblock Abos pflegt doch auch irgendjemand.

Das schöne ist, wenn ich keine Lust mehr drauf habe, zieh ich das ganze wie einen Teppich wieder runter ;D Übrigens bin ich mir der Ironie bewusst auf ein nicht MacbookPro einen Aufkleber mit der Aufschrift “Trust in Aluminium” zu kleben.
Wer mehr sehen will: Link zum FlickR Fotoalbum

x(){ x|x& };x

Im Endeffekt wird die Funktion “x” definiert und darin zweimal aufgerufen. Somit entstehen Prozesse, ich weiss garnicht wie viele ungefähr, vielleicht 1000? vielleicht 25000? Wie hoch ist wohl die Anzahl der Prozesse die ein BSD/Linux aushält? Naja egal ich schweife ab. Genauso wie das System wenn man diesen Code-Schnippsel ausführt.

ps:Aus Gründen der Formatierung habe ich “:” aus der Orginalfassung durch “x” ersetzt. Find ich persöhnlich schöner. Und mein code-block in WordPress mag mich heute irgendwie nicht.

http://320zeichen.de/ – Kahta, Drupal, Web-Montag(e) und ähnliches geistreiches :)

http://raven.to/ – Frank, ebenfalls Drupal und Web-Things, immer für n Smalltalk oder Drupalhilfe gut

http://cryzed.de/ – Chris, Python-fanatic, Blogfauler 4Chan Leser, würde auch CodeMonkey passen.

http://g33ky.de/ – DrAzraelTod höchstpersöhnlich, Nerd und Geek Stuff aller Art.

http://marcboe.de – Marc von Mblog. KDE sein Gebiet. OpenSource Allgemein.

http://thedifferentway.6x.to Razibue, Allround Tech Stuff und Informatik-Student

http://www.twitkrit.de – Muss ich leider passen was Bekanntschaften angeht, lese ich aber doch sehr sehr gerne. Das beste aus der deutsche Twitter-Szene

http://blogausgraz.wordpress.com/ – auch Blogdudel will genannt sein. Android, Linux, Web2.0

http://karl-tux-stadt.de – Zu guter Letzt, den Blog lese ich glaub ich seit ich weiss was ein FeedReader ist. Deckt so ziemlich das ganze OpenSource-Distro Spektrum ab.

Reihenfolge ist übrigens systematisch willkürlich gewählt.

Frage: Ahja und woher genau? Und was hast dafür hingelegt?
Antwort: Von einem hoffungslos Überbezahlten 400 Euro Studenten aus der Arbeit :D, dem ich so ziemlich genau ein Monatsgehalt dafür gegeben habe, also, seins.

Frage: Kannst du das Teil mal herzeigen?
Antwort: Klar…

Frage: Und wie findest du das Teil jetzt so?
Antwort: Mh, Schick
F: Mehr nicht?
A: Alles weitere würde mich hier jetzt als Mac-Fanboy outen und könnte vor Gericht gegen mich verwendet werden.
F: Achso, ja, nachvollziehbar.

Frage: Und jetzt? Keinerlei Gewissensbisse wieder ein kommerzielles OS einzusetzen? Nach mittlerweile 2 Jahren OpenSource? Kritiker behaupten, du wärst auch nur noch eine alte verweichlichte Kommerzschlampe.
Antwort: Da hat, der im Unterton erwähnte, Chris wohl Recht. Aber wer intressiert sich schon für dessen Meinung ? :D Ich bin nur ein Opfer des Kaptialismus

Frage: Wie gehts mit deinen Linuxen? Schon OS-X-Server Software bestellt?
Antwort: Dazu möchte ich nichts sagen.
Frage: Wunder Punkt getroffen ha?
Antwort: FU.