Das Nerdlabor

ERROR 2006 (HY000) at line 137: MySQL server has gone away

Das Nerdlabor — Thu, 23 Feb 2012 10:43:00 PST

Wenn man, wie ich einen großen MySQL-Dump (ca. 150 MB) mit

mysql -u root -p -D testdb < dump.sql

importieren will und dabei auf folgenden Fehler gestößt,

ERROR 2006 (HY000) at line 137: MySQL server has gone away

kann man folgende zwei Dinge ausprobieren. Ich hatte dann am Ende beide benutzt.mark

1. max_allowed_packet erhöhen

In der MySQL-Config (bei ArchLinux unter /etc/mysql/my.cnf) den Eintrag max_allowed_packet suchen und erhöhen, z.B. auf

max_allowed_packet = 32M

Das ist ein sehr hoher Wert wenn man bedenkt, dass der default Wert 1M ist. Falls man auf einem Produktivsystem ist, sollte man nach dem Import wieder den alten Wert einstellen. Nicht vergessen den MySQL-Server nach Bearbeitung der Config neuzustarten.

2. mysqldump Optionen ändern

Wichtig ist hierbei die option --skip-extended-insert auszuschalten, die per default eingeschaltet ist. Mein mysqldump Export Befehl sah dann am Ende so aus:

mysqldump -B dbname -u root -p -t --skip-extended-insert --skip-add-drop-table --skip-create-options > dump.sql

Vielleicht hilft’s!

Kollaboratives Arbeiten mit Octopress und GitHub Pages

Das Nerdlabor — Tue, 14 Feb 2012 15:16:00 PST

In diesem Post beschreibe ich einen Workflow, mit dem mehrere Leute mithilfe von Octopress und GitHub Pages einfach, schnell und kostenfrei bloggen können. Ich hatte bereits schonmal ”einen Artikel” über meine Suche nach einer neuen Blogsoftware geschrieben, hier jetzt etwas mehr “hands on” und weniger “rant”. Ursprünglich hatte ich diesen Beitrag als eine Anleitung für Stephan geplant, damit er endlich mal wieder mitbloggen kann. Aber ich dachte, es kann durchaus auch für andere Leute interessant sein. Also los!

Installation

(Im Großen und Ganzen ist diese Installationsanleitung eine zusammengefasste Fassung der Setupanleitung der offiziellen Octopress Dokumentation. Im Zweifelsfall solltest du dort nachschauen, falls irgendwas nicht funktioniert. Wenn das auch nicht hilft, kannst du gerne ein Kommentar schreiben, dann versuche ich zu helfen.)

Lege ein neues Repository auf Github an. Der Name ist egal, am Ende ist dieses Repo (und damit dein Blog) über die Adresse “http://username.github.com/reponame” verfügbar. Bei mir ist es beispielsweise “http://benben.github.com/nerdlabor”.

Für die Installation von Octopress sollte eine Ruby Version größer als 1.9.2 installiert und einsatzbereit sein. Am besten du benutzt den Ruby Version Managre oder kurz RVM. Wie das geht steht im Octopress Ruby Install Guide oder allgemeiner direkt bei RVM.

Bei Octopress gibt es keine richtigen Versionen, also kannst du einfach den aktuellen master-Zweig klonen:

git clone git://github.com/imathis/octopress.git octopress

Jetzt hast du einen Ordner “octopress”. Nun kannst du folgende Befehle eingeben um die Installation zu beenden:

cd octopress
gem install bundler
bundle
rake install

Nun muss das zuvor angelegte Github-Repository als Deploy-Ziel angegeben werden. Dazu

rake setup_github_pages

ausführen und die Repo-Push-Url angeben. Bei mir wäre das “git@github.com:benben/nerdlabor.git”. Octopress sollte alles weitere selbst erledigen.

Jetzt kannst du mit

rake generate
rake deploy

dein neues Blog erstellen und in den gh-pages-Zweig auf Github pushen. Warum gh-pages-Zweig? Weil Github Pages für Projekte so funktioniert. Mehr dazu hier (Abschnitt Project Pages).

Um nun aber auch den eigentlichen Quellcode des Blogs speichern zu können und nicht nur die statischen kompilierten Blogseiten (die bereits im gh-pages-Zweig sind), musst du noch folgendes tun:

git remote add origin (your repo url)

Dieser Befehl fügt dein Repository auf Github als origin hinzu. Also bei mir wäre es dieser Befehl:

git remote add origin git@github.com:benben/nerdlabor.git

Jetzt noch ein

git config branch.master.remote origin

um dein Repository auf github als default zu setzen. Den aktuellen Quellcode kannst du jetzt mit

git add .
git commit -am "initialer blog quellcode"
git push origin master

committen und pushen.

Also nochmal kurz: Im master-Zweig deines Repositories ist dein Blog Quellcode und im gh-pages-Zweig ist dein kompilierter Blog, der dann angezeigt wird.

Nun kannst du die _config.yml bearbeiten um dein Octopress zu konfigurieren. Das Einzige, was am Anfang gebraucht wird, ist eine korrekte Url, die deiner oben genannten Github Project Pages Url entspricht. Committe und pushe deine Änderungen danach in den master-Zweig.

Jetzt bist du endlich bereit und kannst mit dem Bloggen beginnen! Wurde aber auch Zeit!

Bloggen

Obwohl dieser Beitrag für mehrere Benutzer geschrieben ist, macht es auch Sinn wenn man alleine ist, da man a) den Überblick hat was die aktuellste Version ist und b) alles sicher aufgehoben ist und c) der git/GitHub-Workflow das Veröffentlichen so einfach wie ein “git push” macht.

Als erstes ein neues Blogpost-Template anlegen:

rake new_post["Mein neuer Blogposttitel"]

Dieser Befehl legt eine Datei unter octopress/source/_posts/ an. Diese kannst du jetzt mit deinem bevorzugen Editor öffnen. Am besten du beginnst mit den Konfigurationen im Header und verpasst deinem Blogpost ein paar Kategorien. Diese sind bei Octopress das gleiche wie Tags.

categories:
- octopress
- github
- ruby

Jetzt noch deinen Benutzername hinzufügen:

author: ben

Jetzt kannst du anfangen deinen Blogpost zu schreiben. Wenn du eine Vorschau sehen möchtest, dann speichere ab und führe

rake generate
rake preview

aus. Dann kannst du im Browser auf http://localhost:4000/reponame deinen Blog mit deinem neuen Blogpost sehen. Schreibe weiter an deinem Blogpost, speichere und aktualisiere das Browserfenster. Octopress müsste die Änderungen erkennen und die neue Version automatisch generieren solange der “rake preview”-Prozess läuft.

Wenn du zufrieden mit deinem Blogpost bist und denkst er ist gut genug, um die Welt zu verändern dann einfach ein

rake deploy

ausführen und der Blogpost ist in deinem Blog veröffentlicht. Jetzt musst du nur noch deine Änderungen committen und pushen, um auch den Quellcode des Blogposts auf Github zu schieben. Das geht mit

git add .
git commit -am "mein neuer blogpost"
git push origin master

Fertig!

Ein Freund zum mitbloggen einladen

Möchtest du jetzt einen Freund oder Kollegen zum mitbloggen anregen, dann füge ihn als Collaborator auf Github zu deinem Repository hinzu, damit er dort auch hinpushen kann.

Dann kann er das Repository klonen und folgende Befehle ausführen. (Hoffentlich hat er Ruby schon installiert! Wenn nicht, zeig ihm wie es geht, du weißt es ja jetzt.)

gem install bundler
git checkout master
bundle

Jetzt kann er genauso wie du einen Blogpost schreiben, den Blog backen, auf Github deployen und den Quellcode in den master-Branch deines Repositories pushen. Wiederhole diesen Schritt für alle Leute, die du gern in deinem Blog schreiben lassen möchtest.

Happy Collaborative Blogging!

PS: Ich finde Octopress in Kombination mit den Funktionen von GitHub und Github Pages kann man durchaus als Alternative zu manch einem CMS sehen, da Nutzer- und Versionsverwaltung von git/Github einfach genutzt werden können. Was denkt ihr?

Ruby One-Liner für zufällige IP- und MAC-Adressen

Das Nerdlabor — Wed, 18 Jan 2012 14:58:00 PST

Hier mal zwei lustige Einzeiler für die Generierung von zufälligen Fake-IP und Mac-Adressen.

IP-Adresse:

Array.new(4).map!{rand(256)}.join(".")
# => "220.58.246.123"

MAC-Adresse:

Array.new(6).map!{"%02x" % rand(256)}.join(":")
# => "86:c8:11:c6:18:57"

Ich würde mich über weitere praktische Einzeiler (gerne auch in anderen Programmiersprachen!) in den Kommentaren freuen!

Ruby FTP stoppt Upload ohne Error

Das Nerdlabor — Mon, 09 Jan 2012 13:43:00 PST

Ich habe ein kleines Ruby Skript geschrieben, welches einen Ordner mit allen Inhalten (Dateien und Unterordner) per Net::FTP auf einen Server kopiert. Der Upload stoppte aber immer nach ein paar Dateien ohne Fehlermeldung und das Skript lief ohne etwas zu tun weiter. Es hat mich zwei Stunden gekostet, bis ich eine Lösung dafür hatte: Die FTP Verbindung muss explizit in den passiven Modus geschaltet werden:

ftp.passive = true

Scripting mit Blender 2.61 #2

Das Nerdlabor — Fri, 06 Jan 2012 16:08:00 PST

Habe mal den Code vom letzen Blender Post erweitert und etwas Bewegung hinzugefügt. In ein Blender Skript kopieren und im Animationsfenster auf Play drücken.

#import blender stuff
import bpy

#loop through all objects in the scene
#bpy.context.scene.objects is a list
for obj in bpy.context.scene.objects:
    #use only real opbject, not the camera or lamp
    if obj.type == 'MESH':
        #select the current object
        obj.select = True
        #remove the current selected object (which will always be obj)
        bpy.ops.object.delete()

#create a new cube object
bpy.ops.mesh.primitive_cube_add(location=(0, 0, 0))

#define a function which will be called every frame change
def my_func(scene):
    obj = scene.objects[0]
    obj.location.x = scene.frame_current/50
    print("frame #", scene.frame_current)

#remove all handlers
for i in range( len( bpy.app.handlers.frame_change_pre ) ):
        bpy.app.handlers.frame_change_pre.pop()

#append handler
bpy.app.handlers.frame_change_pre.append(my_func)

Neues GNOME 4 Desktop Design

Das Nerdlabor — Fri, 30 Dec 2011 07:39:00 PST

Es sind erste geheime Bilder von Designstudien des GNOME 4 Desktops aufgetaucht.

Scripting mit Blender 2.61

Das Nerdlabor — Tue, 20 Dec 2011 15:03:00 PST

Heute mal aus Spaß und Interesse angefangen, mit dem Pythonscripting in Blender 2.61 rumzuspielen. Nach anfänglichen Schwierigkeiten mit den Objektselektoren habe ich dann doch noch ein kleines Script hinbekommen, welches aber doch ein paar grundlegende Aspekte des Scriptings in Blender zeigt.

#import blender stuff
import bpy

#loop through all objects in the scene
#bpy.context.scene.objects is a list
for obj in bpy.context.scene.objects:
    #use only real opbject, not the camera or lamp
    if obj.type == 'MESH':
        #select the current object
        obj.select = True
        #remove the current selected object (which will always be obj)
        bpy.ops.object.delete()

#create a new cube object
bpy.ops.mesh.primitive_cube_add(location=(0, 0, 0))

#select this object
obj = bpy.context.scene.objects[0]

#move to another location
obj.location = 5.0, 0.0, 0.0


print('----------')
# print all objects
for obj in bpy.data.objects:
    print(obj.name)

Links zum Weiterlesen:

Blender 2.61 Python API

Blender 2.6 Manual

Functional Tests einer Rails 2.3.x Anwendung mit Paperclip und Clearance 0.8.8

Das Nerdlabor — Fri, 28 Oct 2011 14:40:00 PDT

Endlich habe ich mal Zeit gefunden, für eine etwas betagtere Rails-Anwendung (Rails 2.3.14) die Tests zu schreiben. Das Scaffolding erstellt zwar ein Grundgerüst, das aber bei fortgeschrittener Entwicklung immer angepasst werden muss. Die Unit-Tests waren kein großes Problem. Bei den Functional-Tests wurde es schon komplizierter. In der Anwendung kommt Paperclip als Gem zum Einsatz, um verschiedene Models mit einem Bild zu erweitern. Zur Authentifizierung wird Clearance als Plugin verwendet und liegt in Version 0.8.8 vor. Diese Version ist schon etwas älter und zum Testen wird Cucumber empfohlen. Paperclip hat sogenannte Matchers für RSpec. Ich wollte aber keines der beiden benutzen und stattdessen mit Rails-eigenen Mitteln (test/unit) Tests schreiben und die durch das Scaffolding automatisch erstellten Tests erweitern.

Mein erstes Problem waren die Fixtures. Da war es recht schwierig ein Bild festzulegen und somit automatisch laden zu lassen. FactoryGirl hat ein ziemlich gutes Konzept, um Fixtures zu erstellen und wird auch ziemlich häufig verwendet. Damit konnte ich dann ganz einfach Fixtures, sogenannte Factories, mit einer Bilddatei erstellen, die dann von meinem Model und damit von Paperclip anstandslos geschluckt wurden.

test/factories/factories.rb

Factory.define :picture do |picture|
  picture.data    { File.new(RAILS_ROOT + '/test/factories/bg.jpg') }
  picture.author  { "test author" }
  picture.gallery { Factory(:gallery) }
end

Um FactoryGirl anstatt der Standard-Fixtures zu verwenden, habe ich einfach das factory_girl gem zu meiner config/environments/test.rb hinzugefügt,

config/environments/test.rb

config.gem 'factory_girl'

das Laden der Fixtures in der test_helper.rb auskommentiert,

test/test_helper.rb

# fixtures :all

den fixtures Ordner gelöscht und eine factories.rb angelegt. In dieser kann ich nun fleißig Factories mit allerlei Funktionen anlegen. Für weiteres einfach in die FactoryGirl Doku gucken.

Als das erledigt war, konnte ich anfangen die Tests zu schreiben. Da ich Clearance als Authentifizierung verwende, musste ich erst einmal herausfinden, wie ich das Ein- und Ausloggen mit den Tests berwerkstelligen kann. Das Gem ist schon recht alt und deswegen war es etwas schwierig darüber etwas Doku zu finden. Ich habe es wie folgt gelöst.

Meine test_helper.rb bindet die Helpers von Clearance ein.

test/test_helper.rb

require File.join(File.dirname(__FILE__), '..', 'vendor', 'plugins', 'clearance', 'shoulda_macros', 'clearance')

Jetzt kann ich alle meine Tests mit einer setup und teardown methode ausstatten, die die Clearance Methoden sign_in und sign_out nutzen können, um das Ein- und Ausloggen zu bewerkstelligen.

test/functional/pictures_controller_test.rb

def setup
  sign_in
  @picture = Factory.create(:picture)
end

def teardown
  sign_out
  @picture = nil
end

Dabei wird außerdem eine Instanzvariable angelegt, die ich in den Tests anstatt der Fixtures verwende. Andere Teile des Tests, die noch die alten Fixtures verwenden, musste ich noch austauschen.

test/functional/pictures_controller_test.rb

test "should create picture" do
  assert_difference('Picture.count') do
    post :create, :picture => Factory.attributes_for(:picture)
  end

  assert_redirected_to picture_path(assigns(:picture))
end

test "should show picture" do
  get :show, :id => @picture.id
  assert_response :success
end

test "should get edit" do
  get :edit, :id => @picture.id
  assert_response :success
end

test "should update picture" do
  put :update, :id => @picture.id, :picture => Factory.attributes_for(:picture)
  assert_redirected_to picture_path(assigns(:picture))
end

test "should destroy picture" do
  assert_difference('Picture.count', -1) do
    delete :destroy, :id => @picture.id
  end

  assert_redirected_to pictures_path
end

Die kompletten functional-Tests gibt es hier. Damit laufen alle Tests für die Anwendung erfolgreich. Ich bin mir garnicht sicher, ob das der beste Weg ist, um die Tests so zu bauen und daher für Verbesserungsvorschläge dankbar.

Bloggen im Jahr 2011

Das Nerdlabor — Thu, 20 Oct 2011 14:56:00 PDT

So geht es los: Der Server muss umziehen. Und da mir dabei aufgefallen ist, dass nur mein Wordpress Blog und phpMyAdmin den PHP-Interpreter auf dem Server notwendig machten, kam mir dieses gruselige Ding garnicht erst auf den neuen Server drauf. 100% Ruby powered aus kontrolliertem Anbau.

Trotzdem wollte ich den Blog behalten. Am besten irgendwo anders gehostet. Es gibt ja 1000 Plattformen dafür. Dachte ich. Blogger ist zu hässlich. Tumblr zu spartanisch. Wordpress.org ist undurchsichtig und kompliziert. Das ich den Fehler gemacht habe, mein nicht mehr existentes Wordpress Blog damit zu verbinden, hat die Sache dann völlig unbrauchbar gemacht. Dort kann man nicht mal seinen Account löschen. Posterous sah ganz gut aus und hatte eine Wordpress-Importier-Funktion. Also habe ich das ausprobiert und es war die Hölle. Erstens einmal ist es saulangsam und es gibt keine Vorschau beim Schreiben. Das kann man ja noch verkraften, aber was wirklich völlig unbrauchbar war, war der Editor. In der Hilfe von Posterous stand etwas von Markdown Unterstützung für Quellcode. Nur hat das leider bei mir auch nach mehrmaligen Anlauf nie funktioniert, weil dieser sinnlose Editor ständig HTML-Tags reingekracht hat und deswegen Nichts als Markdown erkannt hat. Und so kam es, dass ich kaum noch etwas geschrieben habe, aus dem einfachen Grund weil ich keine Lust hatte, dieses gruselige Interface-Monster namens Posterous zu verwenden.

Irgendwann wollte ich dann mal wieder etwas einigermaßen sinnvolles posten und wagte mich wiedermal an Posterous und scheiterte bei der ersten Zeile Quellcode. Ich gab schnell entnervt auf, verfluchte es und machte mich auf die Suche nach einem neuen Blogsystem. Nun ja, und wer mal nach Blogsystemen, die in Ruby geschrieben sind, gesucht hat, wird wissen, was jetzt kommt. Mephistoblog ist tot. Typo ist eine megafette Railsanwendung und sonst irgendwie nur ein halbes Wordpress. Und mehr ist da dann auch nicht wirklich in Sicht. Man könnte sich natürlich schnell selbst eins zusammenprogrammieren, aber eh das dann den Umfang hat, den man selbst will, dauert es auch eine Weile.

Bloggen im Jahr 2011 schien irgendwie garnicht so leicht zu sein.

Dann fand ich Octopress und sah mir die Sache mal näher an. Nach etwas lesen, war ich ziemlich neugierig auf diese “baked blog”-Geschichte und probierte es aus. Der Converter, der aus meinem alten Wordpress-SQL-Dump Markdown-Dateien macht, war schnell erweitert. Dann noch ein paar Zeilen in der Konfigurationsdatei ausgefüllt und schon konnte es losgehen.

rake new_post["Bloggen im Jahr 2011"]

Die angelegte Datei mit seiner bevorzugten(!) lokalen Editorsoftware öffnen und mit feinstem Markdown füllen. Auf Nimmer-Wiedersehen fürchterliche Web-Editoren, der ihr alle ziemlich schlecht seid!

rake preview

Eine lokale Vorschau erstellen, abchecken ob alles gut ist und mit

rake deploy

die ganze Sache auf den Server schieben. Ich nutze dafür GitHub Pages, welches wirklich sehr einfach einzurichten ist und auch zum Hosten von mehreren Webseiten mit unterschiedlichen Domains geeignet ist. Nun habe ich alles was ich brauche: gehostet, (m)ein guter Editor, Markdown für Quellcode und endlich wieder Spaß beim Bloggen.

Danke Octopress!

JSON, Unicode und UTF-8

Das Nerdlabor — Tue, 27 Sep 2011 10:01:00 PDT

Als ich vor ein paar Tagen mit der API.Leipzig rumspielen wollte, startete ich mit dem RestClient Gem ein paar Anfragen und stieß auf ein Anfangs komisches Problem:

RestClient.get 'http://www.apileipzig.de/api/v1/district/streets', :params =>{:api_key => '...', :limit => 1}

Dieser Befehl lieferte mir folgendes zurück:

{
  "data": [
      {
          "housenumber": 1,
          "name": "Abrahamstra\u00dfe",
          "created_at": "2011-05-23T21:41:04+02:00",
          "postcode": "04179",
          "district_id": 50,
          "updated_at": null,
          "id": 1,
          "housenumber_additional": "A",
          "internal_key": "06143"
      }
  ]
}

Statt einem ‘ß’ in der Abrahamstraße, also Unicode. Das sah auf den ersten Blick nach einem Fehler beim Encoding aus und ich habe eine Weile gebraucht um das Problem zu lösen. Unter anderem findet sich hier die Lösung:

RestClient funktioniert korrekt. Die API funktioniert ebenfalls korrekt, auch ein lokal aufgesetztes API System lieferte, mit unterschiedlichen Konfigurationen, immer das gleiche Ergebnis. Die Zeile, die in der API schlussendlich eine Ausgabe erzeugt ist

API Leipzig’s JSON Ausgabe link

output.to_json

output ist ein Hash und to_json stammt aus dem JSON Gem, das diesen Hash in JSON umwandelt. Bei dieser Umwandlung werden UTF-8 Zeichen, die nicht im ASCII Zeichensatz vorkommen, in Unicode codepoints umgewandelt. Das machen die meisten JSON Bibliotheken um auch kompatibel zu Empfängern zu sein, die kein UTF-8 empfangen können. Als ich dann ins JSON RFC geschaut hatte, wurde mir einiges klar:

If the character is in the Basic Multilingual Plane (U+0000 through U+FFFF), then it may be represented as a six-character sequence: a reverse solidus, followed by the lowercase letter u, followed by four hexadecimal digits that encode the character’s code point. The hexadecimal letters A though F can be upper or lowercase. So, for example, a string containing only a single reverse solidus character may be represented as “\u005C”.
JSON RFC Punkt 2.5 www.ietf.org/rfc/rfc4627.txt/…

Weiterlesen im RFC…

JSON text SHALL be encoded in Unicode.
The default encoding is UTF-8.
JSON RFC Punkt 3 www.ietf.org/rfc/rfc4627.txt/…

Alle neueren Browser berücksichtigen das und wandeln automatisch bei der Anzeige von reinem JSON in UTF-8. Das klärt auch die Frage, warum Chromium und Firefox alles korrekt anzeigen, während mein eigenes kleines Script Probleme machte. Wer aber keine JSON Bibliothek benutzen möchte, kann aus dem Unicode wieder reines UTF-8 machen:

Lösung link

response = RestClient.get 'http://www.apileipzig.de/api/v1/district/streets', :params =>{:api_key => '...', :limit => 1}
puts response.gsub!(/\\u([0-9a-z]{4})/) {|s| [$1.to_i(16)].pack("U")}

Nun hat die Abrahamstraße wieder ihr ‘ß’ und ich kann weiterarbeiten. Gut zu Wissen! :)

Turn on the Bright Lights

Das Nerdlabor — Tue, 05 Jul 2011 09:44:00 PDT

Wie verpasst man den Diffs aus git wundervolle Farben?

So:

git config --global color.diff yes

Einfache Diashow unter Linux

Das Nerdlabor — Thu, 07 Apr 2011 23:30:06 PDT

Für eine Familienfeier musste ich zuletzt eine einfache Diashow mit etwa 60 Bildern erstellen, die während der gesamten Veranstaltung auf einer Leinwand gezeigt werden sollte. In der Vergangenheit habe ich Bildershows unter Windows mit Photodex ProShow Producer erstellt. Leider hatte ich diesmal keinen Windowsrechner zur Verfügung und konnte deshalb nur auf Open Source Programme unter Linux hoffen. Und ja, was soll ich sagen, mit dem freien Tool PhotoFilmStrip habe ich ein einfaches, aber leistungsstarkes Tool gefunden. Die offizielle Seite findet ihr hier Viel Spaß beim Testen

SEO Optimierung von HEROKU Rails 3 App

Das Nerdlabor — Fri, 01 Apr 2011 00:45:33 PDT

Bei einem letzten Projekt wurde gewünscht, dass alle Anfragen auf eine bestimmte Domain umgeleitet werden. Außerdem sollten Anfragen der Art “domainName.de” auf “www.domainName.de” umgeleitet werden - alles im Sinne der SEO und Google Gemeinde. Dafür bot sich natürlich eine Middleware an. Im Netz wurde ich auch schnell bei Github fündig.

https://github.com/iSabanin/www_ditcher

Die dort verwendete Schleife habe ich natürlich umgetauscht, damit alle Anfragen auf www.. weitergeleitet werden. Doch damit war es nicht genug. Die Seooptimierung wollte auch die von Heroku angebotene Domain appname.heroku.com auf die www-Domain weiterleiten. Ich habe hierfür den Quellcode der Middleware angepasst:

class WwwDitcher

    def initialize(app, redirect_url)
      @app = app
      @url = redirect_url
    end

    def call(env)
      request = Rack::Request.new(env)

      if request.host.match(/(heroku.com)\z/)
        unless @url.nil?
          [301, {"Location" => @url}, self]
        else
          @app.call(env)
        end
      else
        if request.host.starts_with?("www.")
          @app.call(env)
        else
          [301, {"Location" => request.url.sub("//","//www.")}, self]
        end
      end

    end

    def each(&block)

    end

end

Nun musst du die Middleware in production.rb einbinden:

Demo:Application.configure do
  # Settings specified here will take precedence over those in config/environment.rb
  # .......


  # Middleware for redirect
   config.middleware.use "WwwDitcher", ENV["HEROKU_REDIRECT_URL"]
end

Bei der Registrierung der Middleware musst du den Namen der Heroku Konfigurationsvariable mit übergeben. Bei mir heißt diese

ENV["HEROKU_REDIRECT_URL"]

Wenn bei der Heroku App noch keine entsprechende Konfigurationsvariable gesetzt wurde, wird die originale Heroku Domain (appname.heroku.com) aufgerufen.

Um die Umleitung zu schalten, musst du nun eine beliebige url definieren:

  heroku config:add HEROKU_REDIRECT_URL="http://google.de"

Vielen Dank fürs lesen

manuelle NVIDIA Grafiktreiberinstallation unter Linux Mint 10 / Ubuntu 10.10 Maverick Meerkat

Das Nerdlabor — Mon, 07 Mar 2011 12:03:12 PST

Aktuelle NVIDIA-Treiber hier herunterladen.

echo "blacklist nouveau" | sudo tee -a /etc/modprobe.d/blacklist.conf
sudo update-initramfs -u

Neustart und nicht per grafischer Oberfläche einloggen, sondern mit STRG+F1 in die Konsole wechseln und dort einloggen.

sudo stop gdm
sudo ./NVIDIA-Linux-(...).run

Installationsanweisungen folgen und fertig.

erste Tests DVB-T per UDP ins Netzwerk zu streamen (IP-TV)

Das Nerdlabor — Sat, 05 Mar 2011 11:06:49 PST

gst-launch dvbsrc modulation="QAM 64" trans-mode=8k bandwidth=8 frequency=498000000 code-rate-lp=AUTO code-rate-hp=2/3 guard=4  hierarchy=0 ! mpegtsdemux name=demux ! queue max-size-buffers=0 max-size-time=0 ! mpeg2dec ! mpeg2enc ! mpegtsmux ! udpsink

Hier gibt es die Dokumentation für das Modul von Gstreamer: http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-bad-plugins/html/gst-plugins-bad-plugins-dvbsrc.html

Mit Ruby Primzahlen erzeugen

Das Nerdlabor — Thu, 03 Feb 2011 04:48:17 PST

Hier ein kleines Beispiel, wie man mit Ruby Primzahlen erzeugen kann.

require 'prime'

p = Prime.new
(1..100).each do |n|
  q = p.next()
  puts "#{n}: #{q}"
end

MySQL Dump speichern und emailen mit Shellscript

Das Nerdlabor — Wed, 02 Feb 2011 15:29:43 PST

Hier ist ein Quick&Dirty Shellskript um von einer oder mehreren MySQL-Datenbanken ein Backup zu erstellen, es zu komprimieren und per Mail zu verschicken. Kann z.B. einfach von einem Cron-Job jede Nacht ausgeführt werden. Eventuell müssen einige Programme (z.B. “mutt”) installiert werden.

logger "Database Backup Script: Dumping databases..."
mysqldump -B meine_wichtige_db_name anderer_db_name -u backupboy --password='backuppassword' > database_backup.sql
logger "Database Backup Script: Compressing the dump..."
tar -cjf database_backups/`date '+%Y-%m-%d'`_database_backup.tar.bz2 database_backup.sql
logger "Database Backup Script: Mailing the archive..."
mutt -s "Database Backup `date '+%Y-%m-%d'`" -a database_backups/`date '+%Y-%m-%d'`_database_backup.tar.bz2 admin@adminemail.de < /dev/null
rm database_backup.sql
logger "Database Backup Script: finished!"
exit 0

Wordpress url-rewrite mit lighttpd 1.5

Das Nerdlabor — Fri, 28 Jan 2011 08:00:10 PST

Seit dem Update auf lighttpd 1.5 gab es Problem mit den alten rewrite rules. [1]

Hier sind welche für lighttpd 1.5.

rewrite rules for wordpress link

url.rewrite-once = (
"^/(wp-.+).*/?" => "$0",
"^/(sitemap.xml)" => "$0",
"^/(xmlrpc.php)" => "$0",
"^/keyword/([A-Za-z_0-9\-]+)/?$" => "/index.php?keyword=$1",
"^/.*?(\?.*)?$" => "/index.php$1"
)

Pdf generieren mit rails 3, dragonfly und wicked_pdf

Das Nerdlabor — Thu, 27 Jan 2011 11:47:37 PST

Hier möchte ich die wichtigsten Schritte festhalten, um mit dem sehr tollen wicked_pdf plugin PDF Dateien zu erstellen. Dabei soll vor allem die Integrierung von Bilddateien beschrieben werden, die ich mit dem on-the-fly processing/encoding framework dragonfly erzeuge.

Plugin installieren

cd /path/to/rails_app
rails plugin install git://github.com/mileszs/wicked_pdf.git

Statische Version von wkhtmltopdf herunterladen und in neu angelegten Rails Ordner “bin” legen

cd /path/to/rails_app
mkdir bin
# passende statische Version für wkhtmltopdf in diesem Ordner abspeichern

Neuen Initializer in der config für wicked_pdf erstellen mit folgendem Inhalt:

#Datei /path/to/rails_app/config/initializers/wicked_pdf.rb
WickedPdf.config = {
  #:wkhtmltopdf => '/usr/local/bin/wkhtmltopdf',
  #:layout => "pdf.html"
  :exe_path => Rails.root.join('bin', 'wkhtmltopdf-i386').to_s,
}

Den exe_path müsst ihr auf den Namen eurer geladenen wkhtmltopdf-Datei anpassen. Bei mir ist es “wkhtmltopdf-i386”.

In eurem Controller gibt ihr dann an, welche Action auf PDF antworten soll. Die möglichen Optionen findet ihr hier

class MyController < ApplicationController
def show
#...     
respond_to do |format|
      format.html # show.html.erb 
      format.xml  { render :xml => @my }
      format.pdf do
        render :pdf => "my",
        :layout => "pdf.html",
        :disposition => "inline",
        :show_as_html => params[:debug].present?
      end
    end
 end
end

View show.pdf.erb anlegen

#view
<h1>Hallo show von MyController</h1>

In diesem View könnt ihr jetzt ganz normales HTML schreiben, das mit dem entsprechenden Styling für die PDF formatiert wird.

GANZ wichtig:

Alle Resourcen, auf die innerhalb des Views verwiesen wird, müssen eine absolute url aufweisen. Dafür könnt ihr die von wicked_pdf zur Verfügung gestellten Helper verwenden. Sie setzen ein “file://” und den Hauptpfad der Railsapp vor jede Url
Bei generierten Dateien (generiertes Javascript, Css oder Bilder ) könnnen diese Helper natürlich nicht verwendet werden
Hier muss im View selbstständig die eine absolute Url erzeugt werden: Wie dies geht, erfahrt ihr jetzt

Absolute URL’s erzeugen

Es gibt zwei Möglichkeiten, die Urls der verwendeten AssetHelper von Rails absolut zu gestalten:

1

In eurer Enviromentkonfiguration (development.rb, production.rb, test.rb) könnt ihr asset hosts festlegen

ActionController::Base.asset_host = "assets.example.com"

Dies kann aber bei größeren Projekten leicht zu Problemen führen, wenn man mehrere asset hosts verwendet (ist aber mit entsprechendem Aufwand möglich).

2

Ich lasse mir im entsprechenden View alle Angaben zum Request ausgeben und erzeuge daraus die absoluten Url’s. Dies funktioniert vor allem in Verbindung mit Dragonfly perfekt:

#Ermittlung des request, ergibt z.B. http://localhost:3000 bei einer Standard-Rails-Anwendung
<% prefix=request.protocol+request.env['HTTP_HOST'] %> # => http://localhost:3000
# project mit Draognfly macro "cover_image"
<%= image_tag prefix+project.cover_image.url  %>

Alternativ kann auch eine Option von Dragonfly genutzt werden, bei dem der Host festgelegt werden kann:

<% prefix=request.protocol+request.env['HTTP_HOST'] %>
<%= image_tag project.cover_image.url(:host => prefix) %>

Wenn ihr in eurer Testumgebung aber immer noch keine generierten Bilder in der PDF vorfindet oder die PDF Generierung von wkhtmltopdf endlos weiterläuft, müsst ihr in eurer “development.rb” Datei noch folgendes setzen.

config.consider_all_requests_local = false

Ich hoffe, ich konnte euch weiterhelfen

Bis zum nächsten Mal

Auf lighttpd trunk updaten

Das Nerdlabor — Tue, 25 Jan 2011 17:55:10 PST

Lighttpd Trunk besorgen [1] und kompilieren.

apt-get install subversion pkg-config libtool automake libglib2.0-dev
svn checkout svn://svn.lighttpd.net/lighttpd/trunk/
cd trunk
./autogen.sh
./configure --prefix=/usr
make
make install

Statt ‘make install’ kann man auch ein ‘checkinstall’ versuchen.

Für PHP mit FCGI spawn-fcgi besorgen und kompilieren. [2]

svn co svn://svn.lighttpd.net/spawn-fcgi/trunk spawn-fcgi
cd spawn-fcgi
./autogen.sh
./configure --prefix=/usr
make
make install

Statt ‘make install’ kann man auch ein ‘checkinstall’ versuchen.

spawn-fcgi starten. [3]

/usr/bin/spawn-fcgi -s /tmp/php-fastcgi.sock -f /usr/bin/php-cgi -u www-data -g www-data -C 5 -P /var/run/spawn-fcgi.pid

lighttpd.conf anpassen

  $PHYSICAL["existing-path"] =~ "\.php$" {
    proxy-core.balancer = "round-robin"
    proxy-core.protocol = "fastcgi"
    proxy-core.allow-x-sendfile = "enable"
    proxy-core.backends = ( "unix:/tmp/php-fastcgi.sock" )
    proxy-core.max-pool-size = 16
    proxy-core.rewrite-request = (
      "_pathinfo" => ( "\.php(/.*)" => "$1" )
    )
  }

lighttpd neustarten

/etc/init.d/lighttpd restart

Fertig.