Programmer@work

Dual boot Linux SATA HD and Windows IDE HD with GRUB2

Sat, 25 Jun 2011 18:27:45 +0200

Ok vediamo come fare: Creiamo un file /etc/grub.d/11_windows come segue:

#!/bin/sh -e
echo "Found Windows XP" >&2
cat << EOF
menuentry "Window XP" {
drivemap (hd0) (hd1)
drivemap (hd1) (hd0)
set root=(hd1,1)
chainloader +1
}
EOF

Ricordate che in grub2 la mappatura degli HD e delle partizioni e` cambiata:

sda1 => hd0,1
sda2 => hd0,2
sdb1 => hd1,1
sdc2 => hd2,2
…

Ora aggiorniamo il grub.cfg con il comando

sudo update-grub

Dovremmo vedere un output del genere:

Generating grub.cfg ...
Found linux image: /boot/vmlinuz-2.6.38-10-generic
Found initrd image: /boot/initrd.img-2.6.38-10-generic
Found linux image: /boot/vmlinuz-2.6.38-8-generic
Found initrd image: /boot/initrd.img-2.6.38-8-generic
Found Windows XP
Found memtest86+ image: /boot/memtest86+.bin
done

Reboot e viaaa…

init.d script to run Apache SOLR

Fri, 25 Feb 2011 13:57:00 +0100

Copiate il seguente script in /etc/init.d/solr

#!/bin/sh

PATH=/opt/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
NAME=solr
DESC=apache-solr
VERSION=1.4.1
SOLR_PATH=/opt/solr-$VERSION
COMMAND=/usr/bin/java
OPTIONS="-Dsolr.solr.home=$SOLR_PATH/solr -Djetty.home=$SOLR_PATH -jar $SOLR_PATH/start.jar"    
PIDFILE=/var/run/$NAME.pid

test -x $COMMAND || exit 0
test -f $SOLR_PATH/start.jar || exit 0

set -e

case "$1" in
  start)
        if [ -f $PIDFILE ]; then
          echo "$PIDFILE exists. $NAME may be running."
        else
          echo -n "Starting $DESC: "
          start-stop-daemon -b -p$PIDFILE -d$SOLR_PATH --start --quiet --exec $COMMAND -- $OPTIONS
          sleep 3
          echo `ps -ef | grep -v grep | grep "$COMMAND $OPTIONS" | awk '{print $2}'` > $PIDFILE
          echo "$NAME."
        fi
        ;;
  stop)
        if [ -f $PIDFILE ]; then
          echo -n "Stopping $DESC: "
          kill `cat $PIDFILE`
          rm -f $PIDFILE
          echo "$NAME."
        else
          echo "$PIDFILE does not exist. $NAME may be not running."
        fi
        ;;
  restart)
        /etc/init.d/$NAME stop
        sleep 1
        /etc/init.d/$NAME start
        ;;
  *)
        echo "Usage: /etc/init.d/$NAME {start|stop|restart}" >&2
        exit 1
        ;;
esac

exit 0

Goobalize3 Goobalize3 (Google + Globalize3) is useful to auto translate the attributes of your...

Mon, 24 Jan 2011 09:30:49 +0100

Goobalize3

Goobalize3 (Google + Globalize3) is useful to auto translate the attributes of your activerecord models.

If you have a model with some attributes translated with Globalize3 you can in easy way auto translate them via Google Translate.

Installation

As gem: put gem 'goobalize3' in your Gemfile
As plugin: run rails plugin install git@github.com:pioz/goobalize3.git

Requirements

Globalize3

Usage

First of all, you need to create google_translate.yml configuration file in your config folder. Put

api : YOUR_GOOGLE_TRANSLATE_API_KEY

You can get api key at this link: https://code.google.com/apis/console/

Now, you can auto translate all globalized attributes of an activerecord object with

@post.translate

this translate the attributes from current set locale (I18n.locale) to all available locales (I18n.available_locales - I18n.locale).

You can set also the target locales

@post.translate(:it, :en, :de)

Ruby pre-defined variables

Tue, 21 Dec 2010 11:22:07 +0100

$!
$@
$&
$`
$'
$+
$1
$~
$=
$/
$\
$,
$;
$.
$<
$>
$_
$0
$*
$$
$?
$:
$"
$DEBUG
$FILENAME
$LOAD_PATH
$stderr
$stdin
$stdout
$VERBOSE
$-0
$-a
$-d
$-F
$-i
$-I
$-l
$-p
$-v
$-w

The exception information message set by ‘raise’. Array of backtrace of the last exception thrown. The string matched by the last successful match. The string to the left of the last successful match. The string to the right of the last successful match. The highest group matched by the last successful match. The Nth group of the last successful match. May be > 1. The information about the last match in the current scope. The flag for case insensitive, nil by default. The input record separator, newline by default. The output record separator for the print and IO#write. Default is nil. The output field separator for the print and Array#join. The default separator for String#split. The current input line number of the last file that was read. The virtual concatenation file of the files given on command line (or from $stdin if no files were given). The default output for print, printf. $stdout by default. The last input line of string by gets or readline. Contains the name of the script being executed. May be assignable. Command line arguments given for the script sans args. The process number of the Ruby running this script. The status of the last executed child process. Load path for scripts and binary modules by load or require. The array contains the module names loaded by require. The status of the -d switch. Current input file from $<. Same as $<.filename. The alias to the $:. The current standard error output. The current standard input. The current standard output. The verbose flag, which is set by the -v switch. The alias to $/. True if option -a is set. Read-only variable. The alias to $DEBUG. The alias to $;. In in-place-edit mode, this variable holds the extension, otherwise nil. The alias to $:. True if option -l is set. Read-only variable. True if option -p is set. Read-only variable. The alias to $VERBOSE. True if option -w is set.

Use Ruby like PHP

Thu, 18 Nov 2010 01:32:00 +0100

E se volessimo usare Ruby come PHP? Senza Rails o qualche strano framework?
Vediamo come fare con Apache…
Per prima cosa installiamo Apache2

apt-get install apache2

Andiamo ad abilitare l’esecuzione dei CGI con i seguenti comandi:

a2enmod cgid
a2enmod actions

Modifichiamo il file /etc/apache2/sites-available/default e aggiungiamo:


  AddHandler rubypage .rhtml
  Action rubypage /erb.cgi
  AddHandler cgi-script .cgi
  Options Indexes FollowSymLinks MultiViews ExecCGI
  AllowOverride None
  Order allow,deny
  Allow from all

Bene, ora riavviamo apache con /etc/init.d/apache2 restart.
Ora copiano il seguente codice nel file che creerete in /var/www/erb.cgi:

#!/usr/bin/ruby

require 'time'
require 'erb'

time = Time.now.httpdate

HEADERS = <Script Error"
  print "#{ $! }"

  # debug info
  print "Backtrace"
  print "#{$!.backtrace.join("\n")}"

  print "Environment"
  print "#{ENV.keys.map { |key| key + ' = ' + ENV[key] + "\n"} }"

  print ""
  print "#{__FILE__} -- #{time}"

end

Bene! Ricordiamo i permessi chmod 755 /var/www/erb.cgi

Infine creiamo il nostro file in Ruby (/var/www/test.rhtml):

<%= 'Hello World' %>
YEAH

Visitiamo http://localhost/test.rhtml

Run a rake task with Capistrano

Thu, 21 Oct 2010 16:21:00 +0200

Beh aggiungiamo una ricetta al nostro deploy.rb

desc "Run a task on a remote server."  
task :invoke do
  if ENV['task']
    run("cd #{deploy_to}/current && rake #{ENV['TASK']} RAILS_ENV=production")
  else
    puts 'usage: cap invoke TASK=task_name'
  end
end

A questo punto possiamo lanciare il rake task sul server remoto:

cap invoke TASK=asset:packager:build_all

Shared repository with git

Wed, 04 Aug 2010 23:21:00 +0200

Per creare una repository condivisa (read+write permissions) da piu` utenti appartenenti allo stesso gruppo createla col seguente comando:

git init --shared=true

Per condividere una repository gia` esistente:

git repo-config core.sharedRepository true

MacPorts memo

Thu, 29 Jul 2010 11:27:54 +0200

Update MacPorts

sudo port selfupdate

List all avaiable ports

port list

Display installed ports

port installed

Display outdated ports

port outdated

Search ports

port search gtk

Get info of a port

port info rb-gtk2

Install a port

sudo port install rb-gtk2

Deletes all intermediate files that MacPorts creates while building a port

sudo port clean --all rb-gtk2

Upgrade a port

sudo port upgrade rb-gtk2

Uninstall a port

sudo port uninstall rb-gtk2

Upgrade all outdated ports

sudo port upgrade outdated

Check PageRank of a website with Ruby

Wed, 21 Jul 2010 23:43:16 +0200

Vediamo un’ottima gemma per Ruby per verificare il PageRank di Google di un sito web. La gemma in questione si chiama pageranker e la potere installare nel classico modo:

sudo gem install pageranker

Una volta installata potete usarla nei seguenti due modi:

$ pageranker 'pioz.it'

oppure da integrare nel vostro codice:

irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'pageranker'
=> true
irb(main):003:0> Pageranker::check('google.it')
=> 8
irb(main):004:0> Pageranker::check('http://www.google.com')
=> 10
irb(main):005:0> Pageranker::check('dsadasdasdsadrfer.com')
=> nil

Molto semplice e utile. Per maggiori info visitate la homepage: http://github.com/pioz/pageranker

Per usare i tasti HOME ed END nel modo classico (HOME va...

Wed, 21 Jul 2010 13:45:00 +0200

Per usare i tasti HOME ed END nel modo classico (HOME va all’inizio della riga, END alla fine).

Recursive call: Ruby vs Python

Fri, 16 Jul 2010 18:01:00 +0200

Facciamo un piccolo test: calcoliamo Fibonacci ricorsivamente in Ruby (v1.9.1) e in Python (v2.5.1) e vediamo chi vince

Ruby Fibonacci code (f.rb)

def fib(n)
  if n == 0 || n == 1
    n
  else
    fib(n-1) + fib(n-2)
  end
end

36.times { |i| fib(i) }

Python Fibonacci code (f.py)

def fib(n):
  if n == 0 or n == 1:
    return n
  else:
    return fib(n-1) + fib(n-2)

for i in range(36):
  fib(i)

Ora lanciamo i due programmi nel seguente modo:

time ruby f.rb && time python f.py

E vediamo l’output:

real    0m9.956s
user    0m9.875s
sys     0m0.034s

real    0m24.471s
user    0m24.060s
sys     0m0.074s

Ecco Ruby impiega 9.956 secondi mentre Python 24.471 secondi!

Ruby vince nettamente su Python!!

Oh beh provate pero` questo codice in C (f.c):

int
fib(int n)
{
  if(n == 0 || n == 1)
    return n;
  else
    return fib(n-1) + fib(n-2);
}

int
main()
{
  int i;
  for(i = 0; i < 36; i++)
    fib(i);
}

Compiliamo:

 gcc f.c

Ed eseguiamo:

time ./a.out

0.546 secondi!

Ruby script to rename and reorder by date your photos

Fri, 02 Jul 2010 02:16:11 +0200

Di seguito uno script che rinomina le foto con estensione jpg o JPG con numero crescente, esempio

cimg0285 -> 001.jpg
cimg0342 -> 002.jpg
....
cimg1078 -> 121.jpg

Inoltre ordina le foto in base alla data di scatto della foto.
Come dipendenza installate la gemma exifr per leggere i metadati di un file JPEG:

sudo gem install exifr

Di seguito il codice:

#!/usr/bin/ruby
# Script by Pioz

require 'rubygems'
require 'exifr'
require 'optparse'

options = {}
optparse = OptionParser.new do |opts|
  opts.banner = "Usage: #{opts.program_name} [options] directory"
  options[:prefix] = ''
  opts.on( '-p', '--prefix PREFIX', 'Add PREFIX to filenames' ) { |prefix| options[:prefix] = prefix }
  options[:outdir] = nil
  opts.on( '-o', '--out-directory DIRECTORY', 'Copy images in DIRECTORY' ) { |outdir| options[:outdir] = outdir }
  opts.on_tail( '-h', '--help', 'Display this screen' ) do
    puts opts
    exit
  end
end
begin
  optparse.parse!
rescue OptionParser::InvalidOption
  puts optparse.help
  exit
end
if ARGV.size != 1
  puts optparse.help
  exit
end

dir = ARGV.first
outdir = options[:outdir] || dir
Dir.mkdir(outdir) unless File.exist?(outdir)

dates = {}
Dir["#{dir}/*.{jpg,JPG}"].each_with_index do |path, i|
  dates[path] = EXIFR::JPEG.new(path).date_time_original
end
dates.sort{|x,y| (x[1] || x[0]) <=> (y[1] || y[0])}.each_with_index do |pair,i|
  outname = "#{options[:prefix]}%0#{dates.size.to_s.size}d" % (i+1).to_s + '.jpg'
  if dir != outdir
    require 'ftools'
    File.copy(pair[0], "#{outdir}/#{outname}")
  else
    File.rename("#{dir}/#{outname}", "#{outdir}/tmp_#{outname}") if File.exist?("#{outdir}/#{outname}")
    if File.exist?(pair[0])
      File.rename(pair[0], "#{outdir}/#{outname}")
    else
      File.rename("#{dir}/tmp_#{File.basename(pair[0])}", "#{outdir}/#{outname}")
    end
  end
end

Youtube flv 2 mp3

Tue, 08 Jun 2010 00:41:00 +0200

Vediamo come convertire un video flv di Youtube in mp3 usando ffmpeg.

Per prima cosa dobbiamo ottenere l’URL esatto del video per poter scaricare l’flv. Per far cio` ci serve un token che cambia nel tempo ma che possiamo ottenere dal file video_info; scarichiamolo:

http://www.youtube.com/get_video_info?video_id=VugK063j0Zo

Questo file contiene una serie di valori in stile parametri http. A noi serve quello con chiave token: nell’esempio token=vjVQa1PpcFNk6LFs5OQXj-teHu8POPhx7isbKGtGbOc%3D.

A questo punto abbiamo tutto il necessario per generare l’url per il download diretto del video flv:

http://www.youtube.com/get_video?video_id=VIDEOID&t=TOKEN

nell’esempio:

http://www.youtube.com/get_video?video_id=VugK063j0Zo&t=vjVQa1PpcFNk6LFs5OQXj-teHu8POPhx7isbKGtGbOc%3D

Bene, ora possiamo con ffmpeg ottenere direttamente l’audio del video in formato mp3 con il seguente comando:

ffmpeg -i 'URL DIRETTO DEL VIDEO' -acodec libmp3lame -ac 2 -ab 128kb -vn -y file_output.mp3

Nell’esempio

ffmpeg -i 'http://www.youtube.com/get_video?video_id=VugK063j0Zo&t=vjVQa1PpcFMpsZHHpcVB1lB6w_EvoJYGbZTNi4KQ2g4%3D' -acodec libmp3lame -ac 2 -ab 128kb -vn -y magically_magical.mp3

It’s magical…

Create apt repository

Sat, 15 May 2010 02:15:37 +0200

Vediamo come creare una repository apt. Per far cio` usiamo l’utiliti reprepro:

sudo apt-get install reprepro

ora creiamo una directory di lavoro e il file di configurazione:

mkdir -p repository/conf
nano repository/conf/distributions

Il file distributions sara` una cosa del genere:

Origin: Company name
Label: Pioz's debian repository
Suite: stable
Codename: debian
SignWith: default
Architectures: i386 amd64 source
Components: main non-free contrib
Description: This repository include my programs

Bene a questo punto generiamo la repo con il seguente comando da dentro la cartella repository appena creata:

reprepro includedeb debian pacchetto1.deb pacchetto2.deb ...

Se avete una chiave privata verra` usata per garantire la repository. Bene adesso mettete online la cartella repository e siamo OK.

Per seguiamo i seguenti passi:

Aggiungiamo la chiave pubblica ad apt

echo key.pub | sudo apt-key add -
Aggiungiamo il repo al file /etc/apt/sources.list

deb http://www.pioz.it/repository debian main
Aggiorniamo

sudo apt-get update
Installiamo qualche programma

sudo apt-get install pacchetto1.deb

GIMDB - GTK graphical interface for the Internet Movie DataBase

Sat, 08 May 2010 18:05:00 +0200

gimdb e` un programma che ti permette di esplorare l’Internet Movie DataBase di Amazon. E` scritto in Ruby e usa la libreria grafica GTK. gimdb scarica le informazioni dei film che richiedi e le salva in un database sqlite3 locale.

Puoi creare utenti e salvare per ognuno di loro i film da vedere, i film visti e i film preferiti. gimdb puo` anche lavorare in modalita` offline cercando i film solamente nel database locale.

gimdb potrebbe essere utile se non sai che film guardare e non trovi piu` la lista dei film da guardare che avevi stilato tanto tempo fa…

Dipendenze

ruby
activerecord
sqlite3-ruby
nokogiri
libgnome2 (sudo apt-get install libgnome2-ruby)
libglade2 (sudo apt-get install libglade2-ruby)

Installazione

sudo apt-get install libgnome2-ruby
sudo apt-get install libglade2-ruby
sudo gem install gimdb

Ad ogni modo informazioni piu` dettagliate disponibili nella homepage del progetto: http://github.com/pioz/gimdb

Scrolling with trackpad with Thinkpad on Ubuntu 10.04 - 10.10

Thu, 06 May 2010 14:00:00 +0200

Con questo trick riuscirete a scrillare le pagine usando il trackpad del vostro Thinkpad tenendo premuto il tasto centrale. Create il nuovo file /usr/lib/X11/xorg.conf.d/20-thinkpad.conf e incollateci il seguente:

Section "InputClass"
    Identifier "Trackpoint Wheel Emulation"
    MatchProduct "TrackPoint"
    MatchDevicePath "/dev/input/event*"
    Driver "evdev"
    Option "EmulateWheel" "true"
    Option "EmulateWheelButton" "2"
    Option "Emulate3Buttons" "false"
    Option "XAxisMapping" "6 7"
    Option "YAxisMapping" "4 5"
EndSection

Ora riavviate X.

Se invece stai usando Ubuntu 10.10 sposta il file in /usr/share/X11

 sudo mv /usr/lib/X11/xorg.conf.d/20-thinkpad.conf /usr/share/X11/xorg.conf.d/20-thinkpad.conf

Set Gtk::Label wrap dinamically

Thu, 25 Mar 2010 20:25:00 +0100

Ahime` come si sa` le Gtk::Label non supportano il wrapping dinamico su resize.
Vabbe`, estendiamo Gtk::Label e iimplementiamo il wrap dinamico.
Ecco la classe in Ruby:

require 'gtk2'
class WrapLabel < Gtk::Label
    def initialize(s = '')
      super()
      self.wrap = true
      self.wrap_mode = Pango::WRAP_WORD_CHAR
      self.set_alignment(0.0, 0.0)
      self.text = s
      self.signal_connect_after('size-allocate') do |w, a|
        lw_old, lh_old = self.layout.size
        if lw_old / Pango::SCALE != a.width
          self.layout.set_width(a.width * Pango::SCALE)
          lw, lh = self.layout.size
          self.set_size_request(-1, lh / Pango::SCALE) if lh_old != lh
        end
      end
    end
  end
end

Balloon widget in GTK

Mon, 15 Mar 2010 20:52:06 +0100

Bello vero?? Magari un giorno spieghero` come creare un widget GTK personalizzato manipolando la renderizzazione con Cairo…

Switching ruby1.8 to ruby1.9 in MacOSX

Fri, 12 Mar 2010 16:49:59 +0100

Allora se usate MacOSX e avete installato XCode avrete anche Ruby 1.8. Ora vediamo come installare anche Ruby 1.9 e switchare tra le due versioni.

Per prima cosa usando Macports installiamo Ruby 1.9

sudo port install ruby19

Adesso possiamo questo semplice script in bash per switchare tra le due versioni

#!/usr/bin/env bash

rbv=$(ruby -v)
rv=${rbv:5:3}

function r18 () {
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/erb /usr/bin/erb
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/gem /usr/bin/gem
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/irb /usr/bin/irb
  ln -s /usr/bin/rake.1.8 /usr/bin/rake
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/rdoc /usr/bin/rdoc
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/ri /usr/bin/ri
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/ruby /usr/bin/ruby
  ln -s /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/testrb /usr/bin/testrb
}

function r19 () {
  ln -s /opt/local/bin/erb1.9 /usr/bin/erb
  ln -s /opt/local/bin/gem1.9 /usr/bin/gem
  ln -s /opt/local/bin/irb1.9 /usr/bin/irb
  ln -s /opt/local/bin/rake1.9 /usr/bin/rake
  ln -s /opt/local/bin/rdoc1.9 /usr/bin/rdoc
  ln -s /opt/local/bin/ri1.9 /usr/bin/ri
  ln -s /opt/local/bin/ruby1.9 /usr/bin/ruby
  ln -s /opt/local/bin/testrb1.9 /usr/bin/testrb
}

function cleanruby () {
  rm /usr/bin/erb
  rm /usr/bin/gem
  rm /usr/bin/irb
  rm /usr/bin/rake
  rm /usr/bin/rdoc
  rm /usr/bin/ri
  rm /usr/bin/ruby
  rm /usr/bin/testrb
}

if [ ${rv} = 1.8 ]; then
  echo "Current version is 1.8 swaping to 1.9"
  cleanruby
  r19
elif [ ${rv} = 1.9 ]; then
  echo "Current version is 1.9 swapping to 1.8"
  cleanruby
  r18
fi
exit

Ecco, ora per switchare tra le 2 versioni lanciamo quello script.
Ricordo che dovrete reinstallare tutte le gemme per Ruby 1.9.

GTK ruby application with Glade

Wed, 10 Mar 2010 18:51:20 +0100

Vediamo oggi come creare un’applicazione GTK in ruby utilizzando la potenza di Glade, il disegnatore di interfacce.

Per prima cosa installiamo glade e le librerie necessarie per il tutto:

sudo apt-get install glade
sudo apt-get install libgnome2-ruby
sudo apt-get install libglade2-ruby

Bene ora apriamo Glade e disegnamo la nostra interfaccia.

Salviamola e generaimo il template con:

ruby-glade-create-template interface.glade > interface.rb

Bene vediamo che diavolo abbiamo creato, apriamo il file interface.rb

#!/usr/bin/env ruby
#
# This file is gererated by ruby-glade-create-template 1.1.4.
#
require 'libglade2'

class ProvaGlade
  include GetText

  attr :glade

  def initialize(path_or_data, root = nil, domain = nil, localedir = nil, flag = GladeXML::FILE)
    bindtextdomain(domain, localedir, nil, "UTF-8")
    @glade = GladeXML.new(path_or_data, root, domain, localedir, flag) {|handler| method(handler)}

  end

end

# Main program
if __FILE__ == $0
  # Set values as your own application. 
  PROG_PATH = "interface.glade"
  PROG_NAME = "YOUR_APPLICATION_NAME"
  ProvaGlade.new(PROG_PATH, nil, PROG_NAME)
  Gtk.main
end

Dobbiamo fare una piccola modifica per vedere la finestra: alla fine della funzione initialize aggiungiamo @glade.get_widget('window1').show_all. Ovvero otteniamo la finestra principale, di default glade la chiama window1 e invochiamo show_all.

Lanciamo la miniapp con ruby interface.rb