TommyBlue.it » How-To

Notifiche SMS gratis con Nagios/Icinga e Skebby

TommyBlue — Wed, 18 Jan 2012 11:26:25 +0000

Ho scritto un po’ di codice Ruby in grado di mandare SMS gratis con Skebby utilizzando due account per privati (funziona anche con uno soltanto sia come mittente che destinatario).
L’account Skebby deve essere attivo attivo e dovete aver abilitato username e password (dal pannello di gestione utente).

Lo script è questo:

#!/usr/bin/env ruby
# Copyright 2012 by Tommaso Visconti
#
# This code is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# This code is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# The full text of the GNU General Public License can be found here: http://www.gnu.org/licenses/gpl.txt
require 'net/http'
require 'uri'
require 'cgi'
$SENDER = '393XXXXXXXXX'
$RECIPIENT = '393XXXXXXXXY'
$USERNAME = 'my_username'
$PASSWORD = 'my_password'
# The class sends free SMS using the Skebby API
# @author Tommaso Visconti

class SkebbyGatewaySendSMS

# Initializes the object
# @param username [String] The Skebby username
# @param text [String] The text of the SMS
# @param recipients [Array] The recipients of the message
# @param sender [String] The SMS sender
def initialize(username = '', text = '', recipient = '', sender = '')

@url = 'http://gateway.skebby.it/api/send/smsskebby/advanced/http.php'

sms_method = 'send_sms'

#@recipients = getRecipients(recipients)

@parameters = {
'method' => sms_method,
'username' => username,
'password' => self.getPassword,
'text' => text,
'recipients[]' => recipient,
'sender_number' => sender
}
end

# Sends the HTTP request
# @return [Boolean] The result of the HTTP request
# @note It returns the result of the HTTP request, not the result of the sending. Use getResponse() or printResponse() to check that!
def sendSMS
@response = Net::HTTP.post_form(URI(@url), @parameters)

if @response.message == "OK"
true
else
false
end
end

# Return the response from the server
# @return [Hash] The hash containing the result of the sending
def getResponse
result = {}
@response.body.split('&').each do |res|
if res != ''
temp = res.split('=')
if temp.size > 1
result[temp[0]] = temp[1]
end
end
end

return result
end

# Prints the response in human-readable format
# @return [Boolean] The result of the SMS sending
def printResponse
result = self.getResponse
if result.has_key?('status') and result['status'] == 'success'
puts "SMS sent successfully"
true
else
puts "Error sending the SMS, printing the full trace:"
result.each do |key,value|
puts "\t#{key} => #{CGI::unescape(value)}"
end
false
end
end

# Encodes the recipients in the correct format
# @param recipients [Array] The Array containing the recipients as String in the format 3912345678 (without + or 00 at the beginning)
# @return [String] The String in the format accepted by the server
# @note This method uses CGI::escape to escape the recipients
def getRecipients(recipients)
recipients.inject('') do |result, number|
result < < '&' unless number == recipients.first
result << "recipients[]=#{CGI::escape(number)}"
end
end

# Obtains the password from the command line hiding the input
# @return (String) The given password
def getPassword
unless $PASSWORD.nil?
password = $PASSWORD
else
puts "Password:"
system "stty -echo"
password = $stdin.gets.chomp
system "stty echo"
end
password
end
end

# Example method to send SMS fast
def send_my_sms(text = 'Empty')
gw = SkebbyGatewaySendSMS.new($USERNAME, text, $RECIPIENT, $SENDER)

if gw.sendSMS
gw.printResponse
else
puts "Error in the HTTP request"
end
end

# Send SMS with Icinga/Nagios
if ARGV.size > 0
text = ARGV[0]
send_my_sms(text)
end

Il programma può essere usato da linea di comando passandogli il messaggio come primo argomento oppure potete includerlo in un altro script ruby e usare la classe SkebbyGatewaySendSMS.
Se invece salvate questo script, ad esempio, in /usr/local/icinga/libexec/sms_gateway e lo rendete eseguibile, potete usarlo per far mandare SMS a Icinga. Bisogna intanto definire due comandi in etc/objects/commands.cfg:

# 'notify-service-by-sms' command definition
define command{
        command_name    notify-service-by-sms
        command_line      /usr/local/icinga/libexec/sms_gateway "--Nagios Service Notification-- Host: $HOSTNAME$, State: $HOSTSTATE$ Service $SERVICEDESC$ Description: $SERVICESTATE$ Time: $LONGDATETIME$"
}
# 'notify-host-by-sms' command definition
define command{
        command_name    notify-host-by-sms
        command_line      /usr/local/icinga/libexec/sms_gateway "--Nagios Host Notification-- Host: $HOSTNAME$, State: $HOSTSTATE$, Time: $LONGDATETIME$"
}

Quindi in etc/objects/contacts.cfg aggiungere all’utente icingaadmin (o chi per lui) le notifiche via SMS:

define contact{
        contact_name                    icingaadmin
        use                             generic-contact
        alias                           Icinga Admin
        email                           my_email@domain.com
        host_notification_commands      notify-host-by-sms,notify-host-by-email
        service_notification_commands      notify-service-by-sms,notify-service-by-email
        }

How to fix redmine-mylyn-connector “Server Error: undefined method `visible_by’”

TommyBlue — Wed, 14 Dec 2011 13:11:08 +0000

With version 5324 the method Project.visible_by has been deprecated in favor of Project.visible_condition and redmine-mylyn-connector plugin stopped working with error: Server Error: undefined by `visible_by’.

Here’s the patch you need to fix the plugin:

diff -r redmine-mylyn-connector-2.7.5/app/controllers/mylyn_connector/issues_controller.rb redmine-mylyn-connector-2.7.5-patched/app/controllers/mylyn_connector/issues_controller.rb

63c63

< :conditions => ["#{Issue.table_name}.id in (?) and #{Issue.table_name}.updated_on >= ? and " < < Project.visible_by, issues, cond]

---

>       :conditions => ["#{Issue.table_name}.id in (?) and #{Issue.table_name}.updated_on >= ? and " < < Project.visible_condition(User.current), issues, cond]

79c79

<       :conditions => ["#{Issue.table_name}.id in (?) and " < < Project.visible_by, issues]

---

>       :conditions => ["#{Issue.table_name}.id in (?) and " < < Project.visible_condition(User.current), issues]

diff -r redmine-mylyn-connector-2.7.5/app/controllers/mylyn_connector/projects_controller.rb redmine-mylyn-connector-2.7.5-patched/app/controllers/mylyn_connector/projects_controller.rb

16c16

<       :conditions => [ "enabled_modules.name = 'issue_tracking' AND #{Project.visible_by}"])

---

>       :conditions => [ "enabled_modules.name = 'issue_tracking' AND #{Project.visible_condition(User.current)}"])

diff -r redmine-mylyn-connector-2.7.5/app/controllers/mylyn_connector/queries_controller.rb redmine-mylyn-connector-2.7.5-patched/app/controllers/mylyn_connector/queries_controller.rb

18c18

< :conditions => ["(#{Query.table_name}.is_public = ? OR #{Query.table_name}.user_id = ?) AND (project_id IS NULL OR "  < < Project.visible_by << ")", true, User.current.id],

---

>       :conditions => ["(#{Query.table_name}.is_public = ? OR #{Query.table_name}.user_id = ?) AND (project_id IS NULL OR "  < < Project.visible_condition(User.current) << ")", true, User.current.id],

Accesso SSH inverso

TommyBlue — Thu, 10 Nov 2011 11:09:40 +0000

Può tornare utile accedere via SSH ad un pc/server non pubblico. Capita ad esempio quando un cliente disperato sta provando a mettere le mani sul server impallato e tu stai cercando di dettargli i comandi al telefono (generalmente con pessimi risultati).

Quindi basta avere un server SSH a cui il cliente possa arrivare con un utente da utilizzare.
Supponendo che il server da raggiungere sia ssh-server.test.com e l’utente test, basta che digiti il comando:

ssh -R 9000:127.0.0.1:22 -p 22 -l test ssh-server.test.com -N

Una volta inserita la password la sua console rimarrà “appesa” e voi, dal vostro server, potrete accedere alla sua macchina con:

ssh utente@127.0.0.1 -p 9000

Chiaramente avrete bisogno di un utente sulla sua macchina.

Et voilà, cliente contento e nessuna crisi di nervi per voi nel tentare di spiegargli dove mettere spazi e slash :)

Installare ChiliProject e Gitolite

TommyBlue — Wed, 12 Oct 2011 16:36:58 +0000

In questa guida spiegherò come installare ChiliProject (il fork del più famoso Redmine), Gitolite e come gestire i repository GIT da ChiliProject grazie al plugin (che funziona anche con Redmine) redmine_git_hosting.

Il tutto verrà installato su Ubuntu server 10.04 LTS.

A differenza delle guide che si trovano in giro la mia configurazione farà tutto con i permessi di un utente utilizzando RVM e Passenger. Tutti i comandi che citerò sono lanciati dalla shell dell’utente, quindi quando ho bisogno di permessi elevati utilizzo sudo. L’utente usato sarà lo stesso che userà gitolite, quindi se non volete “sporcare” il vostro potete crearne uno ad-hoc, ad esempio git.

Installare RVM

La wiki del progetto è molto dettagliata. I passaggi, in breve, sono questi.

Iniziamo installando un po’ di pacchetti:

sudo aptitude install build-essential curl libssl-dev zlib1g-dev libreadline5-dev libxml2-dev git-core imagemagick libmagick-dev libmagickcore-dev

Si può quindi installare RVM:

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

Se lo script non lo avesse fatto inserite la seguente riga in fondo a .bashrc (o .zshrc, a seconda di quale shell usate):

[[ -s "/home/drwolf/.rvm/scripts/rvm" ]] && source "/home/drwolf/.rvm/scripts/rvm"

Date comunque una lettura all’output dello script di installazione di RVM.
Riloggatevi e potrete lanciare il comando rvm. Fatelo per installare Ruby, io userò Ruby Enterprise Edition, volendo si può usare Ruby 1.8.7:

rvm install ree
rvm use --default ree

La mia scelta per il database è MySQL, voi fate la vostra:

sudo aptitude install mysql-server libmysqlclient-dev

A questo punto il necessario è installato e posso creare il gemset per ChiliProject e installare le gemme necessarie:

rvm gemset create chiliproject
rvm gemset use chiliproject
gem install bundler

Installare ChiliProject

Come spiegato farò tutto da utente, quindi posso clonare il repository di ChiliProject direttamente nella home:

cd
git clone git://github.com/chiliproject/chiliproject.git
cd chiliproject
git checkout stable

Con bundle è immediato installare le gemme necessarie:

bundle install --without=test sqlite postgres mysql

Se non avete scelto MySQL 5.1 come me guardate la pagina della wiki per lanciare bundler con le giuste opzioni.
A questo punto bisogna creare il database e l’utente per usarlo:

create database chiliproject character set utf8;
grant all on chiliproject.* to 'chiliproject'@'localhost' identified by 'my_password' with grant option;

Questi dati vanno inseriti in ChiliProject, in config/database.yml (fate attenzione all’adapter, che ho cambiato in mysql2):

production:
  adapter: mysql2
  database: chiliproject
  host: localhost
  port: 3306
  username: chiliproject
  password: my_password

Il file database config/database.yml.example è il template da usare per config/database.yml. Stessa cosa dicasi per config/configuration.yml.example. Usate l’apposita pagina della wiki per configurare quest’ultimo file.
Per concludere lanciate questi rake:

bundle exec rake generate_session_store
RAILS_ENV=production bundle exec rake db:migrate
RAILS_ENV=production bundle exec rake redmine:load_default_data

Per testare l’installazione si può lanciare Webrick e collegarsi via HTTP al server sulla porta 3000:

bundle exec script/server -e production

Installare Passenger per Apache

Per servire ChiliProject sulla porta 80 bisogna installare Apache e Passenger:

sudo apt-get install apache2 apache2-threaded-dev libcurl4-openssl-dev
gem install passenger
passenger-install-apache2-module

Terminata l’installazione bisogna creare il file del modulo di apache (/etc/apache2/mods-available/passenger.load) con il contenuto suggerito dall’installer, nel mio caso:

LoadModule passenger_module /home/tommyblue/.rvm/gems/ree-1.8.7-2011.03@chiliproject/gems/passenger-3.0.9/ext/apache2/mod_passenger.so
PassengerRoot /home/tommyblue/.rvm/gems/ree-1.8.7-2011.03@chiliproject/gems/passenger-3.0.9
PassengerRuby /home/tommyblue/.rvm/wrappers/ree-1.8.7-2011.03@chiliproject/ruby

Per attivare il modulo:

sudo a2enmod passenger

Infine bisogna creare un VirtualHost (o modificare, come ho fatto io, quello di default) facendo puntare la DocumentRoot alla cartella /public di ChiliProject:


        ServerAdmin webmaster@localhost

        DocumentRoot /home/tommyblue/chiliproject/public
        
                AllowOverride all              
                Options -MultiViews            
                Order allow,deny
                allow from all
        

        ErrorLog /var/log/apache2/error.log

        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg.
        LogLevel warn

        CustomLog /var/log/apache2/access.log combined

Riavviamo Apache e ChiliProject sarà sulla porta 80. I dati per il primo accesso sono admin/admin.

Installare Gitolite

Come citato nella stessa documentazione di Gitolite i passaggi sono pochi e semplici:

git clone git://github.com/sitaramc/gitolite
cd gitolite
src/gl-system-install
gl-setup ~/YourName.pub

Dove YourName.pub è la vostra chiave pubblica.
La documentazione completa si trova qui: http://sitaramc.github.com/gitolite/

Combinare le due cose

Per permettere la gestione di Gitolite a ChiliProject è necessario il plugin Redmine Git Hosting. Per iniziare bisogna creare una coppia di chiavi per un utente gitolite:

ssh-keyget -t rsa -f gitolite

Si clona quindi il repository di gestione di Gitolite:

git clone YourName@server:gitolite-admin

dove YourName è l’utente che ha la chiave privata della chiave pubblica che avevamo inserito durante l’installazione di Gitolite.
Si sposta il file gitolite.pub in gitolite-admin/keydir e si modifica gitolite-admin/conf/gitolite.conf aggiungendo l’utente gitolite al repository gitolite-admin:

repo    gitolite-admin
        RW+     =   YourName gitolite

Si committa e si pusha. Adesso l’utente gitolite ha i giusti permessi per configurare Gitolite.

A questo punto si torna a lavorare su ChiliProject, creando la cartella ~/chiliproject/.ssh e spostandoci le chiavi pubblica/privata generate precedentemente:

cd ~/chiliproject
mkdir .ssh
cp /somewhere/gitolite .ssh/gitolite
cp /somewhere/gitolite.pub .ssh/gitolite.pub
chmod 700 .ssh
chmod 600 .ssh/gitolite
chmod 644 .ssh/gitolite.pub

Finalmente si può installare il plugin:

cd ~/chiliproject/vendor/plugins
git clone https://github.com/ericpaulbishop/redmine_git_hosting.git
rm -rf redmine_git_hosting/.git

Prima di lanciare la migrazione bisogna modificare il file redmine_git_hosting/init.rb per adattarlo al proprio sistema. Consiglio di leggere direttamente nella wiki il significato dei vari parametri.
Si può quindi lanciare la migrazione, nel mio caso mi ha anche chiesto di aggiungere alcune gemme, quindi:

bundle install
RAILS_ENV=production rake db:migrate_plugins
touch tmp/restart.txt

Adesso loggandosi in Chiliproject, nella pagina “Il mio utente” è possibile inserire la propria chiave pubblica, che deve essere unica (quindi non tra quelle usate finora).

Per concludere si va in Amministrazione > Plugin e si configura il plugin. Le opzioni sono le stesse che si trovano in init.rb. In più ho abilitato Automatically Initialize Git Repositories For New Projects: in questo modo ogni volta che creo un progetto, ChiliProject mi crea un repository Git su cui posso lavorare.

IPv6 in pochi passi con ALIX e SixXS

TommyBlue — Wed, 03 Aug 2011 15:41:51 +0000

Come ormai saprete (1 – 2) ho un debole per gli embedded ALIX di PcEngines. In questo caso userò una scheda 2d13 con RTC, indispensabile perché se il vostro orologio non è sincronizzato con quello del broker IPv4-IPv6 (±30 secondi) non avrete la connessione IPv6!

Come da tradizione il sistema operativo è Debian Voyage, ma tutta la procedura può comunque essere applicata ad una qualsiasi macchina con installato un os Debian-based (a meno di qualche piccola modifica). Per altri sistemi operativi guardate la wiki di SixXS.

SixXS

Il primo passo è, per l’appunto, quello di registrarsi su SixXS e richiedere un account. La registrazione, prima di essere accettata, deve essere verificata manualmente quindi probabilmente potrebbe passare qualche giorno (nel mio caso ci sono voluti pochi minuti).

Una volta ottenuti i dati di accesso bisogna richiedere un tunnel. In questa guida coprirò la configurazione di un tunnel heartbeat con Aiccu. Anche la richiesta del tunnel richiede approvazione, quindi in attesa possiamo configurare il sistema (una volta approvato il tunnel basta inserirne il nome in /etc/aiccu.conf e gli ip in /etc/network/interfaces).

AICCU

Come premesso il sistema deve avere l’ora corretta con uno scarto massimo di 30 secondi, altrimenti AICCU non stabilisce la connessione. Nel più semplice dei casi per farlo basta installare il pacchetto ntp. AICCU logga in /var/log/syslog, ecco il tipico errore per problemi di sincronizzazione:

~# cat /var/log/syslog | grep aiccu

Apr 28 08:50:19 voyage aiccu[1731]: sock_getline() : "200 Client Identity accepted"
Apr 28 08:50:19 voyage aiccu[1731]: sock_printf() : "get unixtime"
Apr 28 08:50:19 voyage aiccu[1731]: sock_getline() : "200 1312374039"
Apr 28 08:50:19 voyage aiccu[1731]: The clock is off by 355469420 seconds, use NTP to sync it!
Apr 28 08:50:19 voyage aiccu[1731]: sock_printf() : "QUIT Aborting: Clock is off by 355469420 seconds "
Apr 28 08:50:19 voyage aiccu[1731]: Couldn't retrieve first tunnel for the above reason, aborting

Una volta sincronizzato l’orario si può procedere installando il pacchetto aiccu . All’installazione vi verranno chiesti i dati di accesso a SixXS. Oltre a questo ho scommentato soltanto due righe in /etc/aiccu.conf, riporto tutto il file:

username MY_USERNAME
password MY_PASSWORD
protocol tic
server tic.sixxs.net
ipv6_interface sixxs
tunnel_id MY_TUNNEL
verbose false
daemonize true
automatic true
requiretls false
makebeats true

Basta adattare le variabili username, password e tunnel_id (tutti dati che vi devono essere dati da SixXS) e il gioco è fatto.
Molte informazioni le potete trovare anche nella wiki di SixXS: http://www.sixxs.net/wiki/Aiccu

Interfaccia di rete

Quando il tunnel ci verrà attivato potremo configurare l’interfaccia, nello specifico inserendo questa configurazione in /etc/network/interfaces (utilizzando i dati che abbiamo ottenuto):

auto sixxs
iface sixxs inet6 v4tunnel
address MY_IPV6_IP
netmask 64
endpoint 213.254.12.34
ttl 64
up ip link set mtu 1280 dev sixxs
up ip route add default via MY_IPV6_GATEWAY dev sixxs

L’IPv4 dell’endpoint è quello italiano, ad ogni modo nella mail di conferma attivazione del tunnel c’è scritto tutto. Il vostro indirizzo IP e quello del gateway differiscono soltanto per l’ultima cifra: :1 per il gateway e :2 per il vostro IP.

Test IPv6

Terminati questi passaggi il nostro IPv6 dovrebbe essere pronto. Riavviamo AICCU e la rete (/etc/init.d/networking restart) e testiamo il tutto pingando (occhio, ci vuole ping6) il gateway IPv6.
Per ulteriore prova si può visitare la home page di SixXS dove un blocchetto verde ci accoglierà con un festante “You’ve got IPv6!”.
Se siete a terminale e volete testare qualche sito in IPv6 fate attenzione che lynx supporta IPv6 mentre links2 no.

Subnet, routing e assegnazione IP

Ora che abbiamo un IPv6 e lo usiamo per navigare da un pc, è giunto il momento di ottenere una subnet /48 per poter assegnare un IPv6 ad ogni nostro apparato (ovvero ai nostri 1.208.925.819.614.629.500.000.000 apparati).

Come al solito il primo passo è richiedere a SixXS una subnet. Una volta ottenuta la rete /48, seguendo la guida nella wiki di Sixxs, andiamo a configurare una /64 per la nostra rete.
Assegniamo staticamente uno di questi indirizzi in /etc/network/interfaces:

iface eth0 inet6 static
address MY_IP_FROM_SUBNET
netmask 64

Riavviata la rete, il nostro ALIX avrà un secondo IPv6 (oltre a quello del tunnel). Per permettere il routing e l’advertising degli indirizzi ip usiamo radvd: non si tratta di un DHCPv6 (al momento non esiste un DHCPv6 veramente funzionante) ma di un router IPv6 che periodicamente invia pacchetti multicast di Router Advertisement per permettere l’autoconfigurazione degli apparati di rete utilizzando gli ip della nostra subnet.
Dopo aver installato il pacchetto radvd bisogna creare il file /etc/radvd.conf con il seguente contenuto:

interface eth0{
AdvSendAdvert on;
prefix MY_IP_FROM_SUBNET/64
{
AdvOnLink on;
AdvAutonomous on;
AdvRouterAddr on;
};
};

Avviamo radvd e abilitiamo il forwarding:

echo "net.ipv6.conf.all.forwarding=1" >> /etc/sysctl.conf
echo "net.ipv6.conf.default.forwarding=1" >> /etc/sysctl.conf
sysctl -p

Se tutto è andato come doveva le macchine nella vostra rete dovrebbero ottenere un indirizzo IPv6 (parlo di Mac e Linux, per Windows arrangiatevi.. :) e navigare IPv6.
Provate ad aprire il sito SixXS per averne conferma:

Firewall IPv6

Una cosa che ben presto si capisce di IPv6 è che le tanto odiate NAT in certi casi facevano comodo. Uno di questi è che un IP privato era privato. Con IPv6 quasi tutto è pubblico e quindi un firewall è indispensabile.

Ho scritto un breve script per ip6tables prendendo spunto dalla wiki si SixXS, dopo averlo personalizzato (dovete settare qualche IP) basta metterlo in /etc/init.d e aggiungerlo al runlevel di default (update-rc.d firewall-ipv6 defaults):

#! /bin/bash

### BEGIN INIT INFO
# Provides: firewall-ipv6
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: IPTables-based IPv6 firewall
### END INIT INFO

set -e

# /etc/init.d/firewall-ipv6: start and stop the ip6tables firewall

IP6="/sbin/ip6tables"

# L'indirizzo IP di questa macchina
THIS_HOST="2001:1418:AAAA:AAAA::2"

# La subnet assegnata da SixXS
SUBNET_PREFIX="2001:1418:BBBB::/48"

stop_firewall() {
# First, delete all:
$IP6 -F
$IP6 -X

$IP6 -P INPUT ACCEPT
$IP6 -P FORWARD ACCEPT
$IP6 -P OUTPUT ACCEPT
}

start_firewall() {
stop_firewall

# Allow anything on the local link
$IP6 -A INPUT -i lo -j ACCEPT
$IP6 -A OUTPUT -o lo -j ACCEPT

# Allow anything out on the internet
$IP6 -A OUTPUT -o sixxs -j ACCEPT

# Allow the localnet access us:
$IP6 -A INPUT -i eth0 -j ACCEPT
$IP6 -A OUTPUT -o eth0 -j ACCEPT

# Filter all packets that have RH0 headers:
$IP6 -A INPUT -m rt --rt-type 0 -j DROP
$IP6 -A FORWARD -m rt --rt-type 0 -j DROP
$IP6 -A OUTPUT -m rt --rt-type 0 -j DROP

# Allow Link-Local addresses
$IP6 -A INPUT -s fe80::/10 -j ACCEPT
$IP6 -A OUTPUT -s fe80::/10 -j ACCEPT

# Allow multicast
$IP6 -A INPUT -s ff00::/8 -j ACCEPT
$IP6 -A OUTPUT -s ff00::/8 -j ACCEPT

# Allow ICMPv6 everywhere
$IP6 -I INPUT -p icmpv6 -j ACCEPT
$IP6 -I OUTPUT -p icmpv6 -j ACCEPT
$IP6 -I FORWARD -p icmpv6 -j ACCEPT

# Allow forwarding
$IP6 -A FORWARD -m state --state NEW -i eth0 -o sixxs -s $SUBNET_PREFIX -j ACCEPT
$IP6 -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT

# SSH verso questa macchina
$IP6 -A INPUT -i sixxs -p tcp -d $THIS_HOST --dport 22 -j ACCEPT

# Accesso a macchine della rete
#$IP6 -A FORWARD -i sixxs -p tcp -d $IP_DA_RAGGIUNGERE --dport $PORTA_DA_RAGGIUNGERE -j ACCEPT

# Set the default policy
$IP6 -P INPUT DROP
$IP6 -P FORWARD DROP
$IP6 -P OUTPUT ACCEPT
}

test -x $IP6 || exit 0

set -e

case "$1" in
start)
echo -e "Starting Firewall"
stop_firewall
start_firewall
;;
stop)
echo -e "Stopping Firewall"
stop_firewall
;;
restart)
echo -e "Restarting Firewall"
stop_firewall
start_firewall
;;
*)
N=/etc/init.d/$NAME
echo "Usage: $N {start|stop|restart}" >&2
exit 1
;;
esac

exit 0

Per essere sicuri che il firewall funzioni si può usare questa applicazione web: http://ipv6.chappell-family.com/ipv6tcptest/. Se tutto va bene il risultato dovrebbe essere questo:

SASS facile con Compass.app

TommyBlue — Tue, 02 Aug 2011 19:56:29 +0000

Compass.app è un’applicazione per MacOSX che aiuta nella compilazione dei file SASS. Una volta configurata tiene sotto controllo i file SASS e li compila al volo in CSS.

Il progetto, scritto in Ruby, è open-source e ospitato su GitHub. Viene venduta l’applicazione compilata a 7$, ma dato che compilarlo è piuttosto semplice (e sono tirchio) me lo sono compilato.

Ecco come ho fatto:

Il primo passo è installare JRuby, che con RVM si limita ad un semplice:

rvm install jruby

Una volta installato creiamo un gemset e installiamo l’unica gemma necessaria: rawr

rvm use jruby
rvm gemset create compassapp
rvm gemset use compassapp
gem install rawr

Fatto questo bisogna clonare il repository git e lanciare qualche rake:

git clone https://github.com/handlino/CompassApp.git
cd CompassApp
rake rawr:compile
rake rawr:bundle:app

Ecco fatto, adesso spostiamo l’app dalla cartella package/osx a Applicazioni e il gioco è fatto :)

Impedire a Spotlight di cercare nel dizionario

TommyBlue — Wed, 27 Jul 2011 00:15:22 +0000

C’è una cosa che odio in maniera viscerale su Spotlight:
il fatto che quando si effettuano delle ricerche viene effettuata anche una ricerca sul dizionario (che, personalmente, non ho mai usato).

La cosa perdipiù impedisce anche il corretto funzionamento dello stesso Spotlight. Un esempio: se cerco la parola “App” probabilmente sto cercando App Store. Quel che accade è che viene cercata la definizione di App ma l’applicazione App Store non viene neanche visualizzata.

Mi segno quindi questo utilissimo comando da console per disabilitare le ricerche di Spotlight nel dizionario:

defaults write com.apple.spotlight DictionaryLookupEnabled NO

P.S. Per i più curiosi la definizione di App è:

app |ap|
noun Computing
short for application (sense 5).

Installazione di Gitorious su Ubuntu server 10.04

TommyBlue — Wed, 01 Jun 2011 14:17:14 +0000

Oggi ho bestemmiato un paio d’ore per installare Gitorious, progetto che mi ha incuriosito e di cui volevo capirne le potenzialità (in ottica di fargli sostituire l’ottimo Redmine). Dato che alla fine sono riuscito a farlo funzionare e non ho trovato una guida fatta a modo, ho deciso di mettere nero su bianco ciò che ho fatto.

L’installazione è stata effettuata su un server virtuale pulito Ubuntu server 10.04 x86_64. Ho provato ad utilizzare RVM e ruby 1.9.2 ma non ci sono riuscito… Ho quindi utilizzato Ruby Enterprise Edition 1.8.7

Per cominciare ho installato un po’ di pacchetti:

apt-get install build-essential zlib1g-dev tcl-dev libexpat-dev libcurl4-openssl-dev postfix apache2 mysql-server mysql-client apg geoip-bin libgeoip1 libgeoip-dev libaspell-dev aspell sqlite3 libsqlite3-dev imagemagick libpcre3 libpcre3-dev zlib1g zlib1g-dev libyaml-dev libmysqlclient15-dev apache2-dev libonig-dev libmagick++-dev zip unzip memcached git-core git-svn git-doc git-cvs irb sphinxsearch uuid uuid-dev openjdk-6-jre

Ho scaricato e installato ActiveMQ 5.5.0:

wget http://www.powertech.no/apache/dist/activemq/apache-activemq/5.5.0/apache-activemq-5.5.0-bin.tar.gz
sudo -s
tar xzvf apache-activemq-5.5.0-bin.tar.gz -C /usr/local/
echo "export ACTIVEMQ_HOME=/usr/local/apache-activemq-5.5.0" >> /etc/activemq.conf
echo "export JAVA_HOME=/usr/" >> /etc/activemq.conf
dduser --system --no-create-home activemq
chown -R activemq /usr/local/apache-activemq-5.5.0/data

Per lanciare ActiveMQ ho utilizzato questo file, copiato in /etc/init.d:

wget http://www.tommyblue.it/wp-content/uploads/2011/06/activemq.txt
sudo mv activemq.txt /etc/init.d/activemq
sudo chmod +x /atc/init.d/activemq
sudo update-rc.d activemq defaults
sudo service activemq start

A questo punto ho scaricato da qui REE e l’ho installato:

sudo dpkg -i ruby-enterprise_1.8.7-2011.03_amd64_ubuntu10.04.deb

dopodichè ho installato RubyGems. Come dicevo prima non sono riuscito ad utilizzare RVM proprio a causa di problemi con le gemme. Per far funzionare il tutto ho dovuto installare tutte le gemme da root:

wget http://production.cf.rubygems.org/rubygems/rubygems-1.8.5.tgz
tar xzf  rubygems-1.8.5.tgz
cd rubygems-1.8.5/
sudo ruby setup.rb
echo "gem: --no-ri --no-rdoc" > ~/.gemrc

Installato RubyGems bisogna installare le gemme. ATTENZIONE: se fin qui ho più o meno seguito le guide che trovate nella webografia, per le gemme ho fatto tutt’altro. Infatti per far funzionare Gitorious, che è scritto con Rails 2.3.x, non è possibile installare le gemme as is dato che molte sono ormai incompatibili con Rails 2. Meglio far fare tutto a Bundler o specificare gemma per gemma la versione da installare. Quindi prima cloniamo il repository di Gitorious:

sudo -s
git clone git://gitorious.org/gitorious/mainline.git /var/www/gitorious
cd /var/www/gitorious
gem install bundler
bundle install
gem install -b -v 1.1 stomp
gem install rmagick passenger stompserver raspell
gem install -v=0.8.7 rake
passenger-install-apache2-module

Al termine dell’ultimo passaggio creare il file /etc/apache2/mods-available/passenger.load con quanto suggerito dallo script precedente. Nel mio caso:

LoadModule passenger_module /usr/local/lib/ruby/gems/1.8/gems/passenger-3.0.7/ext/apache2/mod_passenger.so
PassengerRoot /usr/local/lib/ruby/gems/1.8/gems/passenger-3.0.7
PassengerRuby /usr/local/bin/ruby

Per attivare il modulo:

a2enmod passenger
a2enmod rewrite
a2enmod ssl
a2enmod expires
service apache2 restart

Ok, adesso ho copiato i necessari script di avvio:

cp /var/www/gitorious/doc/templates/ubuntu/git-daemon /etc/init.d/
cp /var/www/gitorious/doc/templates/ubuntu/git-ultrasphinx /etc/init.d/

In /etc/init.d/git-daemon modificare GIT_DAEMON come segue:

GIT_DAEMON="/usr/bin/local/ruby /var/www/gitorious/script/git-daemon -d"

Creare anche /etc/init.d/stomp:

#!/bin/sh
# Start/stop the stompserver
#
### BEGIN INIT INFO
# Provides:          stomp
# Required-Start:    $local_fs $remote_fs $network $syslog
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      1
# Short-Description: Stomp
# Description:       Stomp
### END INIT INFO   

test -f /usr/local/bin/stompserver || exit 0    

. /lib/lsb/init-functions    

case "$1" in
start)  log_daemon_msg "Starting stompserver" "stompserver"
    start-stop-daemon --start --name stompserver --startas /usr/local/bin/stompserver --background --user git
    log_end_msg $?
    ;;
stop)  log_daemon_msg "Stopping stompserver" "stompserver"
    start-stop-daemon --stop --name stompserver
    log_end_msg $?
    ;;
restart) log_daemon_msg "Restarting stompserver" "stompserver"
    start-stop-daemon --stop --retry 5 --name stompserver
    start-stop-daemon --start --name stompserver --startas /usr/local/bin/stompserver --background --user git
    log_end_msg $?
    ;;
status)
    status_of_proc /usr/local/bin/stompserver stompserver && exit 0 || exit $?
    ;;
*)      log_action_msg "Usage: /etc/init.d/stomp {start|stop|restart|status}"
    exit 2
    ;;
esac
exit 0

e /etc/init.d/git-poller:

#!/bin/sh
# Start/stop the git poller
#
### BEGIN INIT INFO
# Provides:          git-poller
# Required-Start:    stomp
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      1
# Short-Description: Gitorious poller
# Description:       Gitorious poller
### END INIT INFO    

/bin/su - git -c "cd /var/www/gitorious;RAILS_ENV=production script/poller $@"

Si possono quindi aggiungere tutti all’avvio:

chmod 755 /etc/init.d/git-ultrasphinx /etc/init.d/git-daemon /etc/init.d/stomp /etc/init.d/git-poller
update-rc.d stomp defaults
update-rc.d git-daemon defaults
update-rc.d git-ultrasphinx defaults
update-rc.d git-poller defaults

Bisogna creare la configurazione di apache. Gitorious utilizza SSL per il login, quindi i VirtualHost sono 2, io ho creato il file /etc/apache2/sites-available/gitorious:


  ServerName MIODOMINIO
  DocumentRoot /var/www/gitorious/public


  
    ServerName MIODOMINIO
    DocumentRoot /var/www/gitorious/public
    SSLEngine on
    SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem
    SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key
    BrowserMatch ".*MSIE.*" nokeepalive ssl-unclean-shutdown downgrade-1.0 force-response-1.0

e quindi l’ho attivato:

a2dissite default
a2ensite gitorious

Torniamo a Gitorious che abbiamo un po’ lasciato indietro. Serve un utente git che sarà il proprietario dell’applicazione:

adduser --system --home /var/www/gitorious/ --no-create-home --group --shell /bin/bash git
chown -R git:git /var/www/gitorious
su - git
cd /var/www/gitorious
mkdir .ssh
touch .ssh/authorized_keys
chmod 700 .ssh
chmod 600 .ssh/authorized_keys
mkdir -p tmp/pids repositories tarballs
cp config/database.sample.yml config/database.yml
cp config/gitorious.sample.yml config/gitorious.yml
cp config/broker.yml.example config/broker.yml

Modificare config/database.yml lasciando soltanto la sezione production e le sue configurazioni. Inserire un utente MySQL con permessi sul database gitorious_production (se non volete creare a mano questo db utilizzate un utente in grado di creare database). Nel file config/gitorious.yml inserite:

production:
  cookie_secret: "FRASESEGRETISSIMAELUNGHISSIMA"
  repository_base_path: "/var/www/gitorious/repositories"
  gitorious_client_port: 80
  gitorious_client_host: gitorious.dw
  gitorious_host: gitorious.dw
  archive_cache_dir: "/var/www/gitorious/tarballs"
  archive_work_dir: "/tmp/tarballs-work"
  hide_http_clone_urls: true
  is_gitorious_dot_org: false

Per il valore di cookie_secret utilizzate l’output del comando apg -m 64.
Ho avuto dei problemi con ActiveSupport, del tipo:

uninitialized constant ActiveSupport::Dependencies::Mutex (NameError)

come suggerito qui li ho superati inserendo require ‘thread’ in config/boot.rb dopo RAILS_ROOT.

A questo punto si può procedere con la migrazione:

su - git
cd /var/www/gitorious
export RAILS_ENV=production
rake db:create
rake db:migrate
rake ultrasphinx:bootstrap

L’ultimo comando dovrebbe restituire un errore ma comunque crea il file di configurazione, che va editato per evitare l’errore. Il file è config/ultrasphinx/production.conf in cui va sostituito base_tags con tags. Effettuata la sostituizione su può lanciare Sphinx con:

rake ultrasphinx:index RAILS_ENV=production
rake ultrasphinx:daemon:start RAILS_ENV=production

Per l’aggiornamento degli indici ho creato il file /etc/cron.d/ultrasphinx:

* */1 * * *       git     cd /var/www/gitorious && /usr/local/bin/rake ultrasphinx:index RAILS_ENV=production

Prima di accedere a Gitorious bisogna creare l’utente admin lanciando, come git, il comando:

env RAILS_ENV=production ruby script/create_admin

Riavviamo i servizi (ed eventualmente il server per essere sicuri che al riavvio Gitorious funzioni correttamente):

service git-daemon start
service apache2 restart

Colleghiamoci al sito e, se tutto è andato bene, iniziamo ad utilizzare Gitorious!

Resta un’ultima cosa da fare per poter pushare correttamente, ovvero creare un link simbolico al file /var/www/gitorious/script/gitorious in una cartella presente nella PATH dell’utente git, io l’ho creato in /usr/local/bin:

ln -s /var/www/gitorious/script/gitorious /usr/local/bin/

Senza questo passaggio al momento del push ottenevo un singolare quanto criptico errore da git:

bash: gitorious: comando non trovato

Webografia

Backup di Zimbra Open Source 7.1.0 con LVM e rsnapshot

TommyBlue — Thu, 21 Apr 2011 14:25:25 +0000

Chiunque abbia mai fatto il backup di un server di posta sa che l’imperativo è “Ridurre il downtime!”.
Ho recentemente modificato lo script di backup che utilizzavo per il server Zimbra (preso da quelli disponibili qui) in modo da utilizzare gli snapshot di LVM e rsnapshot. Adesso il downtime è limitato al tempo di stop/start di Zimbra e al tempo di snapshot di LVM (circa 2 minuti in totale, di cui pochi istanti di snapshot) e posso con calma effettuare il backup utilizzando rsnapshot che permette di effettuare backup incrementali con uno “spreco” di spazio veramente minimo.

La parte riguardante rsnapshot è molto semplice: si deve effettuare il backup della cartella in cui viene montato lo snapshot, ovvero /mnt/tmp_backup/ZimbraBackup/. Il resto della configurazione è standard.

Ecco invece lo script da inserire in /etc/cron.daily/:

#!/bin/bash

# Where the temporary snapshot will be mounted
TEMPDIR="/mnt/tmp_backup"

# The size of the snapshot volume
VOLSIZE="10G"
# Dynamic volsize, change the mountpoint to fit your conf
#VOLSIZE=`df -h | grep /opt | awk '{print $4}'`

# what to backup, in my case: /dev/vg0/opt
VG="vg0"
LV="opt"

# snapshot name
LV_SNAP="ZimbraBackup"

# lvcreate and lvremove commands path
lvcreate_cmd="/sbin/lvcreate"
lvremove_cmd="/sbin/lvremove"

# Choose the backup
#
# monthly => first day of month
# weekly => on sunday
# daily => daily :)

BACKUP_TYPE="daily"

if [ `date +%d` == "01" ]; then
 BACKUP_TYPE="monthly"
elif [ `date +%u` == "7" ]; then
 BACKUP_TYPE="weekly"
fi

echo -e "Backup started at `date`"

# Stop the Zimbra services
before="$(date +%s)"
echo -e "Stopping the Zimbra services..."
/etc/init.d/zimbra stop || exit
echo -e "Creating a snapshot called $LV_SNAP"

# depending on the time it takes to create the backup and the traffic of your server, you may need to increase the 2G value
$lvcreate_cmd -L$VOLSIZE -s -n $LV_SNAP /dev/$VG/$LV

# Create a mountpoint to mount the logical volume to
echo -e "Creating a mountpoint for the LV..."
mkdir -p $TEMPDIR/$LV_SNAP

# Mount the logical volume to the mountpoint
echo -e "Mounting the snapshot..."

# WARNING: if you use xfs you MUST add nouuid option here!
mount -o ro,nouuid /dev/$VG/$LV_SNAP $TEMPDIR/$LV_SNAP/

# Start the Zimbra services
echo -e "Restarting the Zimbra services..."
/etc/init.d/zimbra start || echo -e "ERROR restarting zimbra"

# Calculates and outputs amount of time the server was down for
after="$(date +%s)"
elapsed="$(expr $after - $before)"
hours=$(($elapsed / 3600))
elapsed=$(($elapsed - $hours * 3600))
minutes=$(($elapsed / 60))
seconds=$(($elapsed - $minutes * 60))
echo -e "Server was down for: $hours hours $minutes minutes $seconds seconds"

# Launch rsnapshot to backup
echo -e "Executing $BACKUP_TYPE backup..."
echo -e "rsnapshot $BACKUP_TYPE"
rsnapshot $BACKUP_TYPE

# Unmount /tmp/$lv_zimbra and remove the logical volume
echo -e "Unmounting and removing the snapshot."
umount /dev/$VG/$LV_SNAP
$lvremove_cmd --force /dev/$VG/$LV_SNAP
echo -e "$lvremove_cmd /dev/$VG/$LV_SNAP"

# Done!
echo -e "Backup ended at `date`"

Realizzare un sistema di monitoraggio con Icinga

TommyBlue — Tue, 08 Mar 2011 16:45:38 +0000

In questa breve guida spiegherò come installare Icinga (un fork di Nagios che ha ormai superato il genitore) e Icinga Web su Ubuntu 10.04 server.

Molti passi sono uguali a quelli che ho già descritto nelle due guide sull’installazione di Nagios (1 e 2).

Operazioni preliminari

Installare i pacchetti necessari:

apt-get install apache2 bsd-mailx build-essential libgd2-xpm-dev libjpeg62 libjpeg62-dev libpng12-0 libpng12-0-dev snmp libsnmp-base git-core mysql-server mysql-client libdbi0 libdbi0-dev libdbd-mysql

Aggiungere utenti e gruppi:

addgroup --system icinga
adduser --system --no-create-home --home /usr/local/icinga --ingroup icinga --disabled-password icinga
addgroup --system icinga-cmd
usermod -a -G icinga-cmd icinga
usermod -a -G icinga-cmd www-data

Creare il database:

 #> mysql -u root -p
 mysql> CREATE DATABASE icinga;
 GRANT USAGE ON *.* TO 'icinga'@'localhost' IDENTIFIED BY 'icinga' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0;
 GRANT SELECT , INSERT , UPDATE , DELETE ON icinga.* TO 'icinga'@'localhost';
 FLUSH PRIVILEGES ;
 quit

Scaricare Icinga:

cd /usr/src
git clone git://git.icinga.org/icinga-core.git
cd icinga-core/
git submodule init
git submodule update
./configure --with-command-group=icinga-cmd --enable-idoutils
make all
make fullinstall
make install-api
cd /usr/local/icinga/etc/
cp idomod.cfg-sample idomod.cfg
cp ido2db.cfg-sample ido2db.cfg

Editare i due ultimi file per adattarli alle configurazioni del database. Nel file /usr/local/icinga/etc/icinga.cfg scommentare la riga:

broker_module=/usr/local/icinga/bin/idomod.o config_file=/usr/local/icinga/etc/idomod.cfg

Creare le tabelle:

 #> cd /path/to/icinga-src/module/idoutils/db/mysql
 #> mysql -u root -p icinga < mysql.sql

Edit 15/03/11:
Ho dovuto modificare il file /usr/local/icinga/etc/objects/commands.cfg perchè il path al comando mail era sbagliato, quindi modificate le definizioni di notify-host-by-email e notify-service-by-email per utilizzare /usr/bin/mail e non /bin/mail.

Per terminare aggiungere Icinga ai servizi di avvio e lanciare Ido2db e Icinga:

update-rc.d icinga defaults
/etc/init.d/ido2db start
/etc/init.d/icinga restart

Plugins

Scaricare e installare i plugin di Nagios. Si faccia riferimento alla guida di Nagios per l’installazione, si presti solo attenzione alle differenti opzioni di configurazione:

./configure --prefix=/usr/local/icinga --with-cgiurl=/icinga/cgi-bin --with-htmurl=/icinga --with-nagios-user=icinga --with-nagios-group=icinga

Configurazione dei check

Per la configurazione degli host e dei servizi potete vedere le mie precedenti guide per Nagios: parte 1 e parte 2.

Le interfacce web

Icinga ha a disposizione due interfacce web: la classica interfaccia CGI e la nuova Icinga Web. Le due installazioni possono convivere tranquillamente.

Icinga

Installare i CGI:

make cgis
make install-cgis
make install-html
make install-webconf

Creare l’utente e la password per l’accesso:

htpasswd -c /usr/local/icinga/etc/htpasswd.users icingaadmin

Icinga Web

Installare il necessario:

apt-get install php5 php5-cli php-pear php5-xmlrpc php5-xsl php5-gd php5-ldap php5-mysql
a2enmod rewrite

Scaricare e installare Icinga Web:

cd /usr/src
git clone git://git.icinga.org/icinga-web.git
cd icinga-web
./configure
make install
make install-apache-config

Creare il database e lo schema:

# mysql -u root -p

mysql> CREATE DATABASE icinga_web;
       GRANT USAGE ON *.* TO 'icinga_web'@'localhost' IDENTIFIED BY 'icinga_web' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0;
       GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, ALTER, INDEX ON icinga_web.* TO 'icinga_web'@'localhost';
       quit

# make db-initialize

E, per finire:

/etc/init.d/icinga restart
/etc/init.d/apache2 restart

Se avete utilizzato le impostazioni di default non dovete fare altro, altrimenti date una lettura alla guida ufficiale. Riavviate apache e connettetevi al server: http:///icinga-web

TommyBlue.it » How-To

Notifiche SMS gratis con Nagios/Icinga e Skebby

How to fix redmine-mylyn-connector “Server Error: undefined method `visible_by’”

Accesso SSH inverso

Installare ChiliProject e Gitolite

Installare RVM

Installare ChiliProject

Installare Passenger per Apache

Installare Gitolite

Combinare le due cose

IPv6 in pochi passi con ALIX e SixXS

SixXS

AICCU

Interfaccia di rete

Test IPv6

Subnet, routing e assegnazione IP

Firewall IPv6

SASS facile con Compass.app

Impedire a Spotlight di cercare nel dizionario

Installazione di Gitorious su Ubuntu server 10.04

﻿Webografia

Backup di Zimbra Open Source 7.1.0 con LVM e rsnapshot

Realizzare un sistema di monitoraggio con Icinga

Operazioni preliminari

Plugins

Configurazione dei check

Le interfacce web

Icinga

Icinga Web

Webografia

Webografia