use Rack::CommonLogger

I think this one works at least for most Rack based applications. The application itself runs on thin ( besides that, I only know Unicorn and Rainbow(s?) that have Streaming Support. Webrick won’t do that (yet))

My vhost config.

upstream stream {
  server 127.0.0.1:4800;
  server 127.0.0.1:4801;
  server 127.0.0.1:4802;
  server 127.0.0.1:4803;
  server 127.0.0.1:4804;
}

server {
  listen   80;
  server_name  stream.domain.com;
  client_max_body_size 5M;
  root /path/to/project/current/public;
  error_log	/path/to/project/shared/nginx/stream.error.log;
  access_log  off;
  location / {
    proxy_set_header  X-Real-IP  $remote_addr;
    proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_buffering off;
    proxy_redirect off;

    if (-f $request_filename) {
      break;
    }

    if (!-f $request_filename) {
      proxy_pass http://stream;
      break;
    }

  }
}

which resulted in a circle whose radius was off by about 20% in my tests. ( South Germany; 500m radius ).

of course I had to factor in that this assumes we’re on the equator. To account the current latitude (for the circles’center) I modified the formula:

EARTH_CIRCUMFERENCE * cos(Latitude * PI / 180) / 2 ^ ZOOM_LEVEL / TILE_SIZE

$ export CC=gcc-4.2
$ gem install memcached

mkdir: cannot create directory `/usr/local/rvm': Permission denied

Every Tutorial or Snippet I tried looked liked this:

bash < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer )

To force RVM to your $HOME - or any other folder your user has RW privileges:

$ echo 'export rvm_prefix="$HOME"' > ~/.rvmrc
$ echo 'export rvm_path="$HOME/.rvm"' >> ~/.rvmrc

Then rerun the above bash/curl line.

Load seeds:

namespace :db do
  task :seed => :environment do
    seed_file = File.join(File.dirname(__FILE__), 'db', 'seeds.rb')
    load(seed_file) if File.exist?(seed_file)
  end
end

run Migrations & Rollback

namespace :db do
  desc "Migrate the database through scripts in db/migrate."
  task :migrate => :environment do
    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
    ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
  end
 
  desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
  task :rollback => :environment do
    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
    ActiveRecord::Migrator.rollback('db/migrate/', step)
    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
  end
end

Dump & Load schema(.rb)

namespace :db do
  namespace :schema do
    desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
    task :dump => :environment do
      require 'active_record/schema_dumper'
      File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
      end
    end
 
    desc "Load a schema.rb file into the database"
    task :load => :environment do
      file = ENV['SCHEMA'] || "db/schema.rb"
      load(file)
    end
  end
end

Insert comments with a migration

(found here: http://goo.gl/7JO5T)
(working with activerecord 3.1.1)

module ActiveRecord
  module ConnectionAdapters
    class ColumnDefinition
      attr_accessor :comment
 
      def to_sql_with_comment
        column_sql = to_sql_without_comment
        return column_sql if comment.nil?
        "#{column_sql} COMMENT '#{base.quote_string(comment)}'"
        end
 
      alias_method_chain :to_sql, :comment
    end
 
    class TableDefinition
      def column(name, type, options = {})
        column = self[name] || ColumnDefinition.new(@base, name, type)
        if options[:limit]
          column.limit = options[:limit]
        elsif native[type.to_sym].is_a?(Hash)
          column.limit = native[type.to_sym][:limit]
        end
        column.precision = options[:precision]
        column.scale = options[:scale]
        column.default = options[:default]
        column.null = options[:null]  
        column.comment = options[:comment]
        @columns << column unless @columns.include? column
        self
      end
    end
  end
end

Get comment info for columns collection

module ActiveRecord
  module ConnectionAdapters
    class MysqlColumn
      attr_accessor :comment
    end	
 
    class MysqlAdapter
 
      def columns(table_name, name = nil)
        sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
        columns = []
        result = execute(sql, name)
        result.each { |field| 
          c = MysqlColumn.new(field[0], field[5], field[1], field[3] == "YES") 
          c.comment = field[8] || ""
          columns << c
        }
        result.free
        columns
      end  		  
    end
  end
end

You can use that in your application wherever you need access to the comment (or any other column information)

MyModel.columns_hash.each do |a|
  puts a[1].type.to_s
  puts a[1].name.to_s
  puts a[1].comment if a[1].respond_to?("comment")
end

SchemaDumper

to add comment to schema.rb export

module ActiveRecord
  class SchemaDumper  
    def table(table, stream)
      columns = @connection.columns(table)
      begin
        tbl = StringIO.new
        if @connection.respond_to?(:pk_and_sequence_for)
          pk, _ = @connection.pk_and_sequence_for(table)
        elsif @connection.respond_to?(:primary_key)
          pk = @connection.primary_key(table)
        end
        tbl.print "  create_table #{table.inspect}"
        if columns.detect { |c| c.name == pk }
          if pk != 'id'
            tbl.print %Q(, :primary_key => "#{pk}")
          end
        else
          tbl.print ", :id => false"
        end
        tbl.print ", :force => true"
        tbl.puts " do |t|"
        column_specs = columns.map do |column|
          raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
          next if column.name == pk
          spec = {}
          spec[:name]      = column.name.inspect
          spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
                               'decimal'
                             else
                               column.type.to_s
                             end
          spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
          spec[:precision] = column.precision.inspect if column.precision
          spec[:scale]     = column.scale.inspect if column.scale
          spec[:null]      = 'false' unless column.null
          spec[:comment]   = column.comment.inspect
          spec[:default]   = default_string(column.default) if column.has_default?
          (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
          spec
        end.compact
        keys = [:name, :limit, :precision, :scale, :default, :null, :comment] & column_specs.map{ |k| k.keys }.flatten
        lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
        format_string = lengths.map{ |len| "%-#{len}s" }
        type_length = column_specs.map{ |column| column[:type].length }.max
        format_string.unshift "    t.%-#{type_length}s "
        format_string *= ''
        column_specs.each do |colspec|
          values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
          values.unshift colspec[:type]
          tbl.print((format_string % values).gsub(/,\s*$/, ''))
          tbl.puts
        end
        tbl.puts "  end"
        tbl.puts
        indexes(table, tbl)
        tbl.rewind
        stream.print tbl.read
      rescue => e
        stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
        stream.puts "#   #{e.message}"
        stream.puts
      end
      stream
    end    
  end
end

(copy this snippets somewhere to your app, everything gets done by monkey patching)

Plus: My goal anyway was to have some kind of global observer through all models in my application. So, easy decision – I build my one solution – as always: with “Blackjack and Hookers”.

While browsing the ActiveRecord sources I found the perfect entrance to hook in to the needed callbacks (after_create, after_update and after_destroy).

Step 1: Hook in the callbacks

module ObjectWatcher 	                   
  def self.included(base)
    base.after_create do |obj|   
      puts "Yeah - we got a create"
    end
    base.after_update do |obj|  
      puts "Yeah - we got an update"
    end
    base.after_destroy do |obj| 	
      puts "Yeah - we got a destroy"
    end
  end
end	
[...]
ActiveRecord::Base.send(:include, ObjectWatcher)

After that, the rest was pretty easy an straightforward: Create an Observer. Well: Someone has to receive above signals, and do something with them. If you only need one observer, you easily could do you stuff in the blocks. I’d like to be more flexible and for now, I have already 5 observers listening.

Step 2: Listener

this one gets called by the ObjectWatcher and dispatches to all its listeners (observers)

class ObjectListener
  class << self
    def listeners
      @listeners ||= []
    end
    def listeners=(l)
      @listeners = l
    end
    def run(obj, action)
      mn = "after_#{action}"
      self.listeners.each do |listener|
      	lo = listener.to_s.classify.constantize
        lo.send method_name, obj if lo.respond_to?(mn)
      end
    end 
  end 
end

Usage in ObjectWatcher:

[...]
  base.after_create do |obj|   
    ObjectListener.run record, :create
  end
[...]

Step 3: Create & Register Observers

class TestObserver
  def self.after_update(record)
    puts " >> updated"
  end   
  def self.after_create(record)
    puts " >> created" 
  end
  def self.after_destroy(record)
    puts " >> destroyed"
  end
end
[...]
ObjectListener.listeners << TestObserver

that’s it – happy coding.

Well, it took me about two days to figure out some kind of workaround (no real “solution” yet).

Before you continue

… you should check if you really have the same issue:

ping google.com
should give you host not found. If  you receive packets from Google you’re obviously fine – what are you doing here anyway?

Next test, if you indeed get a “host not found” result from ping command, your NAT by typing

ping 123.123.123.123
Please, change 123.123.123.123 to some IP address you know to be reachable ( and responds to ping (icmp packets) ).

Workaround

Plain simple: Modify the guests DHCP settings to get IP settings but use your preferred Nameserver.

Ubuntu (Debian should be the same):
vi /etc/dhcp3/dhclient.conf

edit the line
prepend domain-name-servers 124.124.124.124

124.124.124.124 should be your preferred Nameserver
restart network
/etc/init.d/networking restart

on a Windows Box it shouldn’t be hard to figure out, where to hack in the DNS settings :-)

for one of my recent projects I had to read the “comment” from an a MySQL table field. After a short look in ActiveRecords ConnectionAdapters for MySQL I realized the existing method uses

SHOW FIELDS FROM `table`

instead of the necessary

SHOW FULL FIELDS FROM `table`

which includes the required “comment” column.

First I added an attribute (accessor) to the MysqlColumn Class to store the comment.

module ActiveRecord
  module ConnectionAdapters
    class MysqlColumn
      attr_accessor :comment
    end	
  end
end

Next, the existing method, that loads and assings attributes like “fieldname”, “size”, “type” needed an upgrade. (Change SQL Statement & Assignment of “comment”)

module ActiveRecord
  module ConnectionAdapters
    class MysqlAdapter
 
      def columns(table_name, name = nil)
        sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
        columns = []
        result = execute(sql, name)
        result.each { |field| 
          c = MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") 
          c.comment = field[8] 
          columns << c
        }
        result.free
        columns
      end 
 
    end
  end
end

Notes:

• For Rails Projects, I think, you need to place this in a .rb file in config/initializers
• In my environment (sinatra) I had to add following requirement:

  require 'active_record/connection_adapters/mysql_adapter'

Tweet
]]> http://www.zerolith.com/activerecord-mysql-adapter-column-comments.html/feed 0 http://www.zerolith.com/aufgeraumt.html http://www.zerolith.com/aufgeraumt.html#comments Tue, 31 May 2011 23:02:19 +0000 Daniel http://www.zerolith.com/?p=3180
• Altes Zeug verworfen (ausgeblendet) – ein paar Artikel schon überarbeitet und wieder freigegeben
• Hier kommen (vermutlich) in Zukunft nur noch ein paar Codeschnipsel.
• Theme ist im Moment das Thematic Framework – ggf. leg ich noch n eigenes Stylesheet drüber.

Lösungen gibt es kaum welche, nur ein paar nicht funktionierende Workarounds.

Geklappt hat aber folgender Tipp:

Ich habe das gleiche Problem gehabt und es vor 2 Wochen dem fleißigen AVM-Team gemeldet. Deren vorläufige Antwort: Als Workaround kann man als Passwort für den USB-SMB-Zugriff ausschließlich dezimale Zahlen (0-9) nehmen, dann funktioniert es.

Das macht mich jetzt schon seit Monaten fuchsig. Da kauft man sich ne AirPort Express, freut sich über die Vorteile von AirTunes und dann bekommt Apple es nicht auf die Reihe dass die iPod.app vom iPhone/iPod touch sich mit dem Gerät verständigt.

Nachdem heute Sonntag ist, ich viel zu früh aufgewacht bin und ich keine Böcke hatte mich auch noch am Sonntag mit der Arbeit rumzuschlagen, hab ich etwas rumgegooglet und experimentiert.

Warum hab ich mittlerweile rausgefunden. Dazu aber “später” mehr.

Auf die AirTunes Technik will ich jetzt mal nicht eingehen. Da man das bestimmt woanders besser nachlesen kann.

( Das folgende läuft ohne Anpassungen prima auf nem Mac. Linux dürfte ebenfalls klappen, ist aber nicht getestet )

Wir brauchen

Um AirTunes ausserhalb von iTunes zu nutzen, gibts bereits ne tolle Bibliothek (hier) und eine Portierung für Ruby  die ich verwende (hier).

Getestet hab ich es mit einem ge-jailbreak-ten iPhone 2G, auf das ich mit OpenSSH zugegriffen hab. Dann via apt die folgenden Packete installiert:

(alles folgende als “root” – Default Passwort beim iPhone ist “alpine”)

ruby, lame, rubygems

apt-get install ruby
apt-get install lame
apt-get install rubygems

Nachdem mir ein

gem --version
1.2.0

nur 1.2.0 ausgegeben hat. Hab ich das dann kurzerhand auch noch aktualisiert:
(1.3.4 weil (bei mir – und laut Google noch ein paar anderen die 1.3.5 nicht funktioniert hat))

gem install rubygems-update -v=1.3.4

Das wars noch nicht ganz:

update_rubygems

Und *tadaaa*

gem --version
1.3.4

Die oben erwähnte Bibliothek “raop-client” holt man sich dann mit dem frischen GEM

gem install raop-client

Ich hab dann im /root Folder, wo ich mir ein simples Vz. “test” angelegt hab, weitergearbeitet:

cd ~
mkdir test
cd test

( Albern das zu Dokumentieren? )

Musik? Musik!

Über SCP hab ich mir vom Mac ne MP3 File auf das iPhone kopiert:

scp ~/Music/test.mp3 root@192.168.100.5:/root/test

192.168.100.5 ersetzt ihr natürlich durch eure iPhone IP

“Der” Player

So: jetzt kommt das Ruby-Script (das Ihr z.b. als airtunes.rb lokal speichert.

require 'rubygems'
require 'raop'
 
raop = Net::RAOP::Client.new(ARGV[0])
raop.connect
raop.volume=2
raop.play $stdin
raop.disconnect

… und dann vorzugsweiße auch mit SCP auf eure überteuerte Funkhupe kopiert:

scp ~/airtunes.rb root@192.168.100.5:/root/test

Press Play on Tape

immer noch im ~/test Verzeichnis! Sagen wir dem lame-Encoder unsere vorhin kopierte MP3 Datei zu dekodieren (ins WAV Format – was anders versteht die AirPort nicht). Das ganze schieben wir über ne Pipe an unser eben gebautes Player-Script.

lame --decode test.mp3 - | ruby airtunes.rb 192.168.100.6

wobei hier die 192.168.100.6 (natürlich) durch eure AirPort Express IP ersetzt wird.

Wichtig: Die “raop” Bibliothek (der Ruby Port) kommt anscheinend noch nicht mit Passwortgeschützen AirTunes Lautsprechern klar. (Wobei ich mich damit noch nicht auseinandergesetzt hab. Zum Testen hab ich lediglich das Passwort auf Leer gesetzt.

Und? Hört ihr was?

Wenn man lange genug wartet (in meinem Fall ~20 Sekunden) kommt was :D (soviel zum “Proof of Concept”). Bei mir aber höchsten 4 – 8 Sekunden Bruchstücke.

Ich bin mir leider noch nicht sicher an WAS es liegt: Ob der lame Decoder auf nem 2G zu langsam ist, die WLAN Verbindung damit nicht klar kommt, oder schlimmstenfalls beides. Natürlich kann auch Ruby an sich zu langsam sein.

Nächste Woche gibts für mich hoffentlich das 3Gs mit dem ich den Spaß nochmals probieren werde. Vorausgesetzt natürlich, ich bekomm den Jailbreak hin.

Ich will ne App!

Ich auch :-) . Neben der Tatsache dass -ICH- weder mit dem iPhone SDK noch mit Objective C gearbeitet hab; keine Ahnung hab ob man den dekodierten Stream der iPod.app abfangen kann, oder wie man auf die iTunes Library zugreift um die Audio-Files zu dekodieren (Und das ohne JB).

Halte ich für ein Gerücht dass Apple eine App, die via Reverse Engineering das “geheime” Protokoll nachgebaut hat, zulässt.