Nun habe ich kürzlich einem großen Zündfunk-Fan, der selten Zeit hat ihn zu hören, diesen Mitschnitt als Podcast zum Geburtstag geschenkt. Das ganze wurde aufwändiger als ich dachte und setzt sich mittlerweile zusammen aus:

1. Screen Scraping der B2 Programmwebsite mit scrAPI – incl. Datumskorrektur weil das Programm nicht um Mitternacht umbricht sondern um 5 Uhr früh,
2. diese Daten in einer SQLite DB cachen um nicht mehrmals am Tag zu scrapen (wenn man z.B. noch andere Sendungen aufnimmt),
3. per cron einige Minuten vor Sendungsbeginn den streamripper starten (v1.62.3 wegen alter glib auf Debian Linux),
   • da der einige Zeit zum Starten braucht triggere ich Sendungsbeginn und -ende zeitlich exakt über ein Script, das Titelwechsel in den laufenden Streamripper injiziert – der B2 Stream liefert selbst keine Sendungsinfos,
4. falls der Stream zwischendurch unterbrochen wurde setzen wir die verschiedenen mp3 Dateien zu einer zusammen (ohne Überblendung per Holzhammer: cat)
5. Sendungsinfos parallel zum mp3 als xml speichern, um nach Aufnahmeende von der DB unabhängig zu sein,
6. aus allen vorhandenen mp3+xml Paaren ein Podcast RSS bauen und mit gzip packen,
7. tägliche Gleitlöschung (mp3 älter als 3 Wochen) per cron+find damit die Platte nicht volläuft.

Den Podcast abonniert man schließlich z.B. mit iTunes und bekommt direkt nach der Sendung die frische Zündfunkfolge incl. komplettem Text zur Sendung frei Haus.

Das komplette Ruby Script gibts bei github.

Einfach die Datei in den (lokalen) Dropbox/Public Ordner verfrachten, syncen lassen und per “Rechte Maustaste -> Copy Public Link” in die Mail kopieren.

Redirect

Nun sind solche Links nicht besonders hübsch (Branding!, Branding!, CI! ruft die Marketingabteilung) und  spätestens wenn man’s abtippen muß oder per Telephon weitersagt wird’s gruslig.

Hat man aber eine eigene Website, lassen sich die Dropbox Links aufhübschen und eine Weiterleitung einrichten, dann wird aus

http://dl.dropbox.com/u/1234567/BigDocument.pdf

z.B.

http://dropbox.mydomain.com/BigDocument.pdf

und schon sind die Brandingfreunde happy.

index.html

Geht es nicht um eine einzelne Datei sondern um mehrere, will man evtl. eine Übersicht in einer index.html haben. So eine Übersicht legt z.B. mein ruby Script htmlizedb an. Das Script will im Terminal in dem Verzeichnis gestartet werden, für das die Übersicht her soll.

Redirect + index.html

Bei Webservern ist allgemein üblich, daß man den Dateinamen index.html im Link weglassen kann. Der Webserver nimmt dann an man meint selbige. Die Dropbox verhält sich aber in dieser Hinsicht nicht wie ein normaler Webserver, sondern will immer den kompletten Dateinamen.

Hat man aber bereits den Redirect Trick in Benutzung, läßt sich die Redirect Steuerdatei (.htaccess) aufbohren, daß der Redirect die index.html Angabe ergänzt:

RewriteEngine on
# dropbox abbreviation:
# http://www.cimitan.com/blog/2008/09/17/htaccess-to-redirect-on-dropboxs-public-folder/#
# last path component has no dot -> redirect to index.html
RewriteRule ^(.+/)?([^./]+)/?$	http://dl.dropbox.com/u/1234567/$1$2/index.html	[last,qsappend]
# everything else: redirect as is
RewriteRule ^(.+)$	http://dl.dropbox.com/u/1234567/$1	[last,qsappend]

violá, nun wird von

http://dropbox.mydomain.com/FolderWithBigFiles

automatisch auf den Dropbox Link

http://dl.dropbox.com/u/1234567/FolderWithBigFiles/index.html

weitergeleitet.

Toll, nicht?

Also – automatisieren. Das folgende Ruby-Script erledigt das, nachdem der Rechnungsanhang in einen der Ordner “Downloads” oder “Desktop” gelegt wurde:

#!/usr/bin/ruby
 
dst="#{ENV['HOME']}/Documents/tmobile"
 
# 1. pull together all pgp crypted find Rechnung_15.10.2009.zip.pgp in Desktop, Downloads, local dir
["#{ENV['HOME']}/Downloads", "#{ENV['HOME']}/Desktop", dst].each do |dir|
  Dir.foreach(dir) do |file|
    m = /Rechnung_(\d{2})\.(\d{2})\.(\d{4})\.zip(\.pgp|\.gpg)?/.match file
    if m
      s = system "mv #{dir}/#{file} #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip#{m[4]}"
      s = system "gpg #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip#{m[4]}" if m[4]
      system "rm #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip#{m[4]}" if s && m[4]
      s = system "unzip #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip"
      system "rm #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip" if s
      puts "de-crypted & unpacked #{dst}/#{m[3]}-#{m[2]}-#{m[1]}-bill.zip"
    end
  end
end
 
# 2. rename unpacked files accordingly
Dir.foreach(dst) do |file|
  m = /^Rechnung_(\d{4})_(\d{2})_(.+)$/.match file
  system "mv #{dst}/#{file} #{dst}/#{m[1]}-#{m[2]}-bill-#{m[3]}" if m
  m = /^Einzelverbindungsnachweis_(\d{4})_(\d{2})_(.+)$/.match file
  system "mv #{dst}/#{file} #{dst}/#{m[1]}-#{m[2]}-evn--#{m[3]}" if m
  m = /^Rechnung_(\d{5,20})_(\d{2})_(\d{4})(.+)$/.match file
  system "mv #{dst}/#{file} #{dst}/#{m[3]}-#{m[2]}-bill-#{m[1]}#{m[4]}" if m
  m = /^Einzelverbindungsnachweis_(\d{5,20})_(\d{2})_(\d{4})(.+)$/.match file
  system "mv #{dst}/#{file} #{dst}/#{m[3]}-#{m[2]}-evn--#{m[1]}#{m[4]}" if m
end

require 'date'
 
class Apache
  def self.each_request(src=$stdin)
    ip_pat=/(?:[0-9]+\.){3}[0-9]+/
    date_pat=/\[[^\]]+\]/
    req_pat=/"([A-Z]+)\s([^\s]+)\s([^\s]+)"/
    ref_pat=/"([^"]+)"/
    date_fmt = '[%d/%b/%Y:%H:%M:%S %Z]'
    apache_pat = Regexp.new( "(#{ip_pat})\s([^\s]+)\s([^\s]+)\s" < <
      "(#{date_pat})\s#{req_pat}\s([0-9]+)\s(-|[0-9]+)\s#{ref_pat}\s#{ref_pat}")
    src.each_line do |l|
      m = apache_pat.match l
      if m
        r = { :ip => m[1],
          :uid => m[2],
          :auth => m[3],
          :date => DateTime.strptime(m[4],date_fmt),
          :method => m[5],
          :url => m[6],
          :http => m[7],
          :status => m[8],
          :bytes => m[9],
          :referrer => m[10],
          :agent => m[11] }
        yield r
       else
        $stderr.puts "Unparseable line: '#{l}'"
      end
    end
  end
end

maybe there are faster ways, but it’s quite convenient this way.

1. Get gammu and backup the phone data:
   $ gammu backup phonedata.txt -yes
2. open phonedata.txt and save it in “MacRoman” encoding with Unix line endings
3. run it through this ruby script:

   #!/usr/bin/ruby -w -- 
    
   # http://www.rubycentral.com/pickaxe/
   # http://homepage.mac.com/phrogz/CSV2vCard_v2.html
    
   records = {}
   fields = {}
    
   eor = /^[ \t]*$/
   bor = /^\[([^0-9\]]+)([0-9]*)\]$/
   etype = /^Entry([0-9]+)Type\s+=\s+(\S+)$/
   etext = /^Entry([0-9]+)Text\s+=\s+"(.*)"/
    
   record_type = nil
   entry_type = nil
   tmp = nil
    
   $stdin.each do |l|
   	if (eor =~ l) == 0
   		records[record_type] = [] if records[record_type].nil?
   		records[record_type] << tmp if tmp
   #		puts '-- EOR --'
   		record_type = entry_type = tmp = nil
   		next
   	end
   	m = bor.match l
   	if m
   #		puts "#{m[1]} - #{m[2]}"
   		record_type = "#{m[1]}"
   		tmp = {}
   		next
   	end
   	if 'PhonePBK' == record_type
   		m = etype.match l
   #		raise "Parse Error: #{l}" if entry_type.nil? && m.nil?
   		if m
   			entry_type = "#{m[2]}"
   		else
   			m = etext.match l
   			if m
   				raise 'Parse Error' if entry_type.nil?
   				if 'Name' == entry_type
   					name = "#{m[2]}".split ' '
   					tmp[entry_type = 'LastName'] = "#{name[name.length-1]}"
   					fields[entry_type] = entry_type
   					name[name.length-1] = nil
   					name.compact!
    
   					count = 0
   					name.each do |tn|
   						tmp[entry_type = "Name_#{count}"] = tn
   						fields[entry_type] = entry_type
   						count += 1
   					end
   				else
   					fields[entry_type] = entry_type
   #					puts "#{entry_type} = #{m[2]}"
   					tmp[entry_type] = "#{m[2]}"
   				end
   				entry_type = nil
   			end
   		end
   	end
   end
    
   keys = fields.keys.sort
   sep = ','
   puts "\##{keys.join(sep)}"
   records['PhonePBK'].each do |item|
   	tmp = ''
   	keys.each do |key|
   		v = item[key]
   		v = '' if v.nil?
   		v.gsub! "'", "''"
   		tmp = "#{tmp}'#{v}'#{sep}"
   	end
   	puts tmp
   end

4. run the result through a csv to vcard converter,
5. remove all single quotes ' from the vcards,
6. import the vcards into the osx addressbook.

And guess what – that really works! The script is quite a hack but does the job. I thought about rewriting it using closures prior publishing but left it as a homework to you.

[Update] Maybe iSync would have done the trick, too.

Ragel habe ich für ein Experiment (ist SVG als 2D Szenengraph Format für piccolo2d machbar?) benutzt um einige Parser zu bauen.

Als Vorlage dienten die BNF Grammatiken direkt aus der W3C SVG Spezifikation. Nachdem der erste funktionsfähige Stand erreicht war habe ich noch ein anderes Projekt entdeckt, das genau dasselbe Problem ebenfalls mit Ragel gelöst hat und mich von deren Ansatz Mehrdeutigkeiten aufzulösen inspirieren lassen.

Schön ist dabei

• BNF Grammatiken direkt verwerten (die vom W3C mußten fast nur von unten nach oben umgedreht werden),
• dadurch glasklare Definition der erlaubten formalen Sprache,
• keinerlei Abhängigkeiten von irgendwelchen Libs,
• irre schneller Parser-Code,
• Ragel läuft auf zig Systemen,
• Ragel spuckt aktuell C, C++, Objective-C, C#, D, Java und Ruby aus,
• wird von richtig hellen Köpfen benutzt (nette Beispiele im Netz),
• und die Doku taugt auch noch was!

Für die Ruby Freunde unter uns gibt’s auch einen speziellen netten Blog Eintrag.