Utilizando Espeak como alternativa de sintetización de voz

Durante las entradas relacionadas con el proyecto Jarvis de sintetización de voz, hemos estado utilizando combinaciones entre Festival y mbrola. 

Como se detectaron problemas para que las frases emitidas ofreciesen cierta calidad en la entonación, he continuado mis pruebas con más software de sintetización de voz, buscando obtener una voz femenina adecuada.

Un de ellos es Espeak, bajo estas líneas indico los comandos para su instalación y su uso básico.

Para la instalación, simplemente teclearemos:

sudo apt-get install espeak
o bien, 
sudo aptitude install espeak

Para su uso utilizaremos:

espeak -ves+f1 "¿Qué tal se escucha esta pregunta?"

Donde -v irá acompañada del lenguaje a utilizar en la reproducción (en este caso español - es) y mediante el uso de + añadimos el tipo de voz a utilizar (en este caso f1 corresponde a female 1, voz de mujer con entonación grave). Para poder ver los tipos de voces disponibles en múltiples lenguas, podremos utilizar:

espeak --voices

Y si deseamos ver las variantes de dichas voces, teclearemos:

espeak --voices=variant

Existen ciertas variaciones como temblor en la voz o susurro, croack y whisper. Éstos pueden ser utilizados mediante:

espeak -ves+whisper "Esto es un susurro"

Coloreando la salida de un ShellScript Linux

Continuando con el proyecto JARVIS de transformación de texto a voz, os paso el código fuente de un ShellScript para Linux en el que se han introducido algunos modificadores para ofrecer una salida por consola en diferentes colores. De este modo, conseguiremos diferenciar mejor qué es texto del propio software y cuál es el que ha sido introducido por el usuario para ser emitido posteriormente en formato sonoro.

Adicionalmente, para acelerar y simplificar la interacción con el script se ha incluido un pequeño menú con las funciones más básicas de respuesta, pregunta y emisión de mensajes.

#!/bin/bash

function colorea()
{
#La siguiente línea colorea el texto a emitir
#pasado como parámetro
echo -e '\E[37;44m'"\033[1m$1\033[0m"
#El color es texto blanco sobre fondo azul
}

function texto()
{
#La siguiente línea colorea el texto
#pasado como parámetro
echo -e '\E[37;45m'"\033[1m$1\033[0m"
#El color es texto blanco sobre fondo morado
}

function menu()
{
clear
echo "*************************"
echo "*  ¿QUÉ QUIERES DECIR?  *"
echo "*************************"
echo " 1 - Sí "
echo " 2 - No "
echo " 3 - No lo sé "
echo " 4 - Tengo una duda "
echo " 5 - Quiero responder "
echo " 6 - Quiero decir algo..."
echo " x - Salir"
}


function habla()
{
    echo
    colorea "$1"   
    echo "$1" | iconv -f utf-8 -t iso-8859-1 | festival --tts
   
   
}

function duda()
{
    clear   
    texto "Introduce tu PREGUNTA, cuando pulses INTRO se emitirá: "
    read pregunta
    habla "Mi pregunta es: $pregunta"
    habla "Vuelvo a repetirla"
    habla "$pregunta"
}

function respuesta()
{
    clear
    texto "Introduce tu REPUESTA, cuando pulses INTRO se emitirá: "
    read respuesta
    habla "Mi respuesta es: $respuesta"
    habla "repito"
    habla "$respuesta"
}

function deciralgo()
{
    clear
    texto "Introduce tu MENSAJE: "   
    read mensaje
    habla "Tengo algo que decir:"
    habla "$mensaje"
    habla "Lo repetiré una vez más"
    habla "$mensaje"
}

clear
iniciosonido="Sintetizador activado y en espera. pulsa x para terminar"
habla "$iniciosonido"

echo


opcion=""
while [ "$opcion" != "x" ]
do
   
    menu   
    read -p "Indica qué quieres decir: " opcion
    case $opcion in
        1)colorea "Sí";habla "Sí";;
        2)colorea "No";habla "No";;
        3)colorea "No lo sé";habla "No lo sé";;
        4)duda;;
        5)respuesta;;
        6)deciralgo;;
        x)echo "Sintetizador detenido"; echo "Sintetizador detenido" | iconv -f utf-8 -t iso-8859-1 | festival --tts;;
        *)echo "Opción no válida, vuelve a intentarlo";;
    esac

done

Script instalación/configuración Conversor Texto a Voz - Jarvis

Como complemento a una entrada anterior, publicamos hoy un script de instalación y configuración del conversor de texto a voz que he llamado Jarvis.

Se trata de una combinación entre festival y mbrola, añadiendo una voz femenina (Silvia) generada por la gente de Guadalinex, el paquete .deb puedes descargarlo directamente desde este enlace: Descargar voz Femenina de Forja Guadalinex o si quieres descargar la versión definitiva anterior, hazlo desde este enlace (festvox-sflpc16k_1.0.0_all.deb).
 
El script lleva a cabo la instalación de los programas necesarios (aptitude para hacer las instalaciones, festival y mbrola como elementos de sintetización de voz), descarga automáticamente la última versión de la voz femenina creada en uno de los proyectos de Forja guadalinex, a continuación copia los archivos de configuración retocados previamente en la ubicación adecuada y finalmente, lanza un script de prueba para ver si todo ha sido instalado/configurado satisfactoriamente.

Preparativos para que todo funcione adecuadamente:

a) Crea una carpeta en tu home en la que debes alojar los scripts, los archivos de configuración y el .deb de la voz femenina.

b) Entra en dicha carpeta y crea en ella dos archivos voices.scm y languages.scm. Copia y pega en cada uno de ellos las líneas de configuración que se te facilitan más abajo. Esta configuración ya está preparada para reconocer la voz femenina que vamos a descargar.

c) Una vez tengas los dos archivos (voices y languages), copia el código fuente del instalador y llámalo instala.sh. Dale permisos de ejecución, pero no lo lances aún.

d) Copia el código fuente del script de prueba de sintetizador y llámalo jarvis.sh. Dale permisos de ejecución. No lo lances aún.

Antes de llevar a cabo la ejecución, asegúrate que en la carpeta que has creado se encuentran los siguientes archivos:

• voices.scm (archivo de configuración de la voz)
• languages.scm (archivo de configuración del lenguaje)
• instala.sh (es el instalador)
• jarvis.sh (script para probar el funcionamiento)

Realizando la ejecución:
Una vez tengas todos los elementos en la carpeta, lanza el script de instalación y supervisa los mensajes que te vaya mostrando por si existe algún problema con la versión de algún paquete o librería.

¿Qué es lo que ha ido ocurriendo?

1. Si todo ha ido bien, se habrán instalado automáticamente: aptitude, festival y mbrola. 
2. Se habrán descargado el paquete .deb y habrá sido instalado mediante dpkg. Este paquete será festvox-sflpc16k_1.0.0_all.deb (versión estable) o festvox-sflpc16k_1.0-1_all.deb (última versión que es la que se desarga en el script). 
3. Se habrán copiado los archivos de configuración voices.scm y languages.scm a la carpeta de festival adecuada. 
4. Y, finalmente, se habrá invocado al script de prueba del sintetizador (jarvis.sh), quedando a la espera de que teclees algo para reproducirlo por tu sistema de audio.

Ya sólo queda que modifiques, si tú quieres, el script de prueba para que diga lo que tú quieras. Y eso es todo, a partir de aquí os dejo el código fuente de los scripts, así como de los archivos de configuración retocados.

CÓDIGO FUENTE DEL INSTALADOR/CONFIGURADOR (instala.sh)

#!/bin/bash

#Script de instalación y configuración de
#sintetizador de voz Festival, combinado con
#Mbrola. Adicionalmente se instala el paquete
#de voz femenina de Guadalinex.
error=0
function aptitude()
{
    apt-get install aptitude
    if [ $? -eq 0 ]
    then
        echo "Aptitude instalado satisfactoriamente."
    else
        echo "Error al instalar aptitude."
        error=1
    fi
}

function festival()
{
    #Es posible que alguna de las librerías necesarias cambie de versión, por
    #lo que hay que estar antento a los posibles mensajes de error y warnings

    aptitude install festival festlex-cmu festlex-poslex festvox-kallpc16k libestools1.2 festvox-ellpc11k
    if [ $? -eq 0 ]
    then
        echo "Instalación satisfactoria de Festival."
    else
        echo "Error al instalar Festival."
        error=1
    fi
}

function mbrola()
{
    apt-get install mbrola
    if [ $? -eq 0 ]
    then
        echo "Instalación satisfactoria de mbrola."
    else
        echo "Error al instalar mbrola."
        error=1
    fi
}


function instala()
{
    echo "INSTALACIÓN"
    echo "PASO 1: Instalando aptitude..."
    aptitude
    if [ $error -eq 0 ]
    then
        echo "PASO 2: Instalando Festival..."       
        festival
        if [ $error -eq 0 ]
        then
            echo "PASO 3: Instalando mbrola..."
            mbrola
        fi
    else
        echo "Atención, existen errores previos."
        echo "La instalación se cancelará."
        exit 1
    fi
    echo "Instalación finalizada."
}

function instala_voz()
{

#Descargamos el paquete .deb de la voz femenina en la carpeta en la que nos encontramos

wget http://forja.guadalinex.org/frs/download.php/154/festvox-sflpc16k_1.0-1_all.deb

if [ -f festvox-sflpc16k_1.0-1_all.deb ]
then
    echo "Instalando voz femenina..."
    dpkg -i festvox-sflpc16k_1.0-1_all.deb
    if [ $? -eq 0 ]
    then
        echo "Instalación de voz satisfactoria."
    else
        echo "Error al instalar la voz."
    fi
else
    echo "Error, no existe el fichero de voz."
fi
}

function configura()
{
#En este instante se copiarán los archivos voices.scm y languages.scm
#de Festival ya preconfigurados, a la ubicación definitiva en /usr/share/festival
#y se realizará la instalación de la voz femenina
echo "CONFIGURACIÓN"

ruta="/usr/share/festival/"
echo "Copiando archivos de configuración..."
cp voices.scm $ruta
if [ $? -eq 0 ]
then
    echo "voices.scm copiado con éxito"
fi
cp languages.scm $ruta
if [ $? -eq 0 ]
then
    echo "voices.scm copiado con éxito"
fi
instala_voz
echo "Configuración finalizada."
}

if [ "$USERNAME" == "root" ]
then
    instala
    configura
    read -p "Pulsa una tecla para probar el sintetizador."
    clear
    echo "CONVERSIÓN DE TEXTO A VOZ - JARVIS"   
    echo "Para cerrar pulsa x"
    ./jarvis.sh
else
    clear
    echo "Lo siento, este script debe ejecutarse con privilegios de administrador"
    read -p "El script se cerrará..."
    exit 1
fi

CÓDIGO FUENTE DEL SCRIPT DE PRUEBA DEL SINTETIZADOR DE VOZ (jarvis.sh)

#!/bin/bash

frase=""
while [ "$frase" != "x" ]
do
    read -p "Frase: " frase
    if [ "$frase" != "x" ]   
    then   
        echo $frase | iconv -f utf-8 -t iso-8859-1 | festival --tts
    fi
done

echo "Sintetizador detenido" | iconv -f utf-8 -t iso-8859-1 | festival --tts

LÍNEAS DE CONFIGURACIÓN DEL ARCHIVO DE VOCES(voices.scm)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;                                                                       ;;
;;;                Centre for Speech Technology Research                  ;;
;;;                     University of Edinburgh, UK                       ;;
;;;                       Copyright (c) 1996,1997                         ;;
;;;                        All Rights Reserved.                           ;;
;;;                                                                       ;;
;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
;;;  this software and its documentation without restriction, including   ;;
;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
;;;  permit persons to whom this work is furnished to do so, subject to   ;;
;;;  the following conditions:                                            ;;
;;;   1. The code must retain the above copyright notice, this list of    ;;
;;;      conditions and the following disclaimer.                         ;;
;;;   2. Any modifications must be clearly marked as such.                ;;
;;;   3. Original authors' names are not deleted.                         ;;
;;;   4. The authors' names are not used to endorse or promote products   ;;
;;;      derived from this software without specific prior written        ;;
;;;      permission.                                                      ;;
;;;                                                                       ;;
;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
;;;  THIS SOFTWARE.                                                       ;;
;;;                                                                       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Preapre to access voices. Searches down a path of places.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define current-voice nil
  "current-voice
   The name of the current voice.")

;; The path to search for voices is created from the load-path with
;; an extra list of directories appended.

(defvar system-voice-path '("/usr/share/festival/voices/")
  "system-voice-path
   Additional directory not near the load path where voices can be
   found, this can be redefined in lib/sitevars.scm if desired.")

(defvar system-voice-path-multisyn '( )
  "system-voice-path-multisyn
   Additional directory not near the load path where multisyn voices can be
   found, this can be redefined in lib/sitevars.scm if desired.")

(defvar voice-path
  (remove-duplicates
   (append (mapcar (lambda (d) (path-append d "voices/")) load-path)
       (mapcar (lambda (d) (path-as-directory d)) system-voice-path)
       ))

  "voice-path
   List of places to look for voices. If not set it is initialised from
   load-path by appending \"voices/\" to each directory with
   system-voice-path appended.")

(defvar voice-path-multisyn
  (remove-duplicates
   (append (mapcar (lambda (d) (path-append d "voices-multisyn/")) load-path)
       (mapcar (lambda (d) (path-as-directory d)) system-voice-path-multisyn)
       ))

  "voice-path-multisyn
   List of places to look for multisyn voices. If not set it is initialised from
   load-path by appending \"voices-multisyn/\" to each directory with
   system-voice-path-multisyn appended.")


;; Declaration of voices. When we declare a voice we record the
;; directory and set up an autoload for the vocie-selecting function

(defvar voice-locations ()
  "voice-locations
   Association list recording where voices were found.")

(defvar voice-location-trace nil
  "voice-location-trace
   Set t to print voice locations as they are found")

(define (voice-location name dir doc)
  "(voice-location NAME DIR DOCSTRING)
   Record the location of a voice. Called for each voice found on voice-path.
   Can be called in site-init or .festivalrc for additional voices which
   exist elsewhere."
  (let ((func_name (intern (string-append "voice_" name)))
    )

    (set! name (intern name))
    (set! voice-locations (cons (cons name dir) voice-locations))
    (eval (list 'autoload func_name (path-append dir "festvox/" name) doc))
    (if voice-location-trace
    (format t "Voice: %s %s\n" name dir)
    )
    )
  )

(define (voice-location-multisyn name rootname dir doc)
  "(voice-location NAME ROOTNAME DIR DOCSTRING)
   Record the location of a voice. Called for each voice found on voice-path.
   Can be called in site-init or .festivalrc for additional voices which
   exist elsewhere."
  (let ((func_name (intern (string-append "voice_" name)))
    )

    (set! name (intern name))
    (set! voice-locations (cons (cons name dir) voice-locations))
    (eval (list 'autoload func_name (path-append dir "festvox/" rootname) doc))
    (if voice-location-trace
    (format t "Voice: %s %s\n" name dir)
    )
    )
  )



(define (current_voice_reset)
"(current_voice_reset)
This function is called at the start of defining any new voice.
It is design to allow the previous voice to reset any global
values it has messed with.  If this variable value is nil then
the function wont be called.")

(define (voice_reset)
"(voice_reset)
This resets all variables back to acceptable values that may affect
voice generation.  This function should always be called at the
start of any function defining a voice.  In addition to reseting
standard variables the function current_voice_reset will be called.
This should always be set by the voice definition function (even
if it does nothing).  This allows voice specific changes to be reset
when a new voice is selection.  Unfortunately I can't force this
to be used."
   (Parameter.set 'Duration_Stretch 1.0)
   (set! after_synth_hooks default_after_synth_hooks)

   ;; The follow are reset to allow existing voices to continue
   ;; to work, new voices should be setting these explicitly
   (Parameter.set 'Token_Method 'Token_English)
   (Parameter.set 'POS_Method Classic_POS)
   (Parameter.set 'Phrasify_Method Classic_Phrasify)
   (Parameter.set 'Word_Method Classic_Word)
   (Parameter.set 'Pause_Method Classic_Pauses)
   (Parameter.set 'PostLex_Method Classic_PostLex)

   (set! diphone_module_hooks nil)
   (set! UniSyn_module_hooks nil)

   (if current_voice_reset
       (current_voice_reset))
   (set! current_voice_reset nil)
)


(defvar Voice_descriptions nil
  "Internal variable containing list of voice descriptions as
decribed by proclaim_voice.")

(define (proclaim_voice name description)
"(proclaim_voice NAME DESCRIPTION)
Describe a voice to the systen.  NAME should be atomic name, that
conventionally will have voice_ prepended to name the basic selection
function.  OPTIONS is an assoc list of feature and value and must
have at least features for language, gender, dialect and
description.  The first there of these are atomic, while the description
is a text string describing the voice."
  (let ((voxdesc (assoc name Voice_descriptions)))
    (if voxdesc
    (set-car! (cdr voxdesc) description)
    (set! Voice_descriptions
          (cons (list name description) Voice_descriptions))))
)

(define (voice.description name)
"(voice.description NAME)
Output description of named voice.  If the named voice is not yet loaded
it is loaded."
  (let ((voxdesc (assoc name Voice_descriptions))
    (cv current-voice))
    (if (null voxdesc)
    (unwind-protect
     (begin
       (voice.select name)
       (voice.select cv) ;; switch back to current voice
       (set! voxdesc (assoc name Voice_descriptions)))))
    (if voxdesc
       voxdesc
       (begin
     (format t "SIOD: unknown voice %s\n" name)
     nil))))

(define (voice.select name)
"(voice.select NAME)
Call function to set up voice NAME.  This is normally done by
prepending voice_ to NAME and call it as a function."
  (eval (list (intern (string-append "voice_" name)))))

(define (voice.describe name)
"(voice.describe NAME)
Describe voice NAME by saying its description.  Unfortunately although
it would be nice to say that voice's description in the voice itself
its not going to work cross language.  So this just uses the current
voice.  So here we assume voices describe themselves in English
which is pretty anglo-centric, shitsurei shimasu."
  (let ((voxdesc (voice.description name)))
    (let ((desc (car (cdr (assoc 'description (car (cdr voxdesc)))))))
      (cond
       (desc (tts_text desc nil))
       (voxdesc
    (SayText
     (format nil "A voice called %s exist but it has no description"
         name)))
       (t
    (SayText
     (format nil "There is no voice called %s defined" name)))))))

(define (voice.list)
"(voice.list)
List of all (potential) voices in the system.  This checks the voice-location
list of potential voices found be scanning the voice-path at start up time.
These names can be used as arguments to voice.description and
voice.describe."
   (mapcar car voice-locations))

;; Voices are found on the voice-path if they are in directories of the form
;;        DIR/LANGUAGE/NAME

(define (search-for-voices)
  "(search-for-voices)
   Search down voice-path to locate voices."

  (let ((dirs voice-path)
    (dir nil)
    languages language
    voices voicedir voice
    )
    (while dirs
     (set! dir (car dirs))
     (setq languages (directory-entries dir t))
     (while languages
       (set! language (car languages))
       (set! voices (directory-entries (path-append dir language) t))
       (while voices
     (set! voicedir (car voices))
     (set! voice (path-basename voicedir))
     (if (string-matches voicedir ".*\\..*")
         nil
         (voice-location
          voice
          (path-as-directory (path-append dir language voicedir))
          "voice found on path")
         )
     (set! voices (cdr voices))
     )
       (set! languages (cdr languages))
       )
     (set! dirs (cdr dirs))
     )
    )
  )

;; A single file is allowed to define multiple multisyn voices, so this has
;; been adapted for this. Rob thinks this is just evil, but couldn't think
;; of a better way.
(define (search-for-voices-multisyn)
  "(search-for-voices-multisyn)
   Search down multisyn voice-path to locate multisyn voices."
  (let ((dirs voice-path-multisyn)
    (dir nil)
    languages language
    voices voicedir voice voice-list
    )
    (while dirs
     (set! dir (car dirs))
     (set! languages (directory-entries dir t))
     (while languages
       (set! language (car languages))
       (set! voices (directory-entries (path-append dir language) t))
       (while voices
     (set! voicedir (car voices))
     (set! voice (path-basename voicedir))
     (if (string-matches voicedir ".*\\..*")
         nil
         (begin
           ;; load the voice definition file, but don't evaluate it!
           (set! voice-def-file (load (path-append dir language voicedir "festvox"
                               (string-append voicedir ".scm")) t))
           ;; now find the "proclaim_voice" lines and register these voices.
           (mapcar
        (lambda (line)
          (if (string-matches (car line) "proclaim_voice")
              (voice-location-multisyn (intern (cadr (cadr line)))  voicedir (path-append dir language voicedir) "registerd multisyn voice")))
        voice-def-file)
         ))
     (set! voices (cdr voices)))
       (set! languages (cdr languages)))
     (set! dirs (cdr dirs)))))

(search-for-voices)
(search-for-voices-multisyn)

;; We select the default voice from a list of possibilities. One of these
;; had better exist in every installation.

(define (no_voice_error)
  (format t "\nWARNING\n")
  (format t "No default voice found in %l\n" voice-path)
  (format t "either no voices unpacked or voice-path is wrong\n")
  (format t "Scheme interpreter will work, but there is no voice to speak with.\n")
  (format t "WARNING\n\n"))

(defvar voice_default 'no_voice_error
 "voice_default
A variable whose value is a function name that is called on start up to
the default voice. [see Site initialization]")

(defvar default-voice-priority-list
  '(JuntaDeAndalucia_es_sf_diphone
    kal_diphone
    cmu_us_bdl_arctic_hts
    cmu_us_jmk_arctic_hts
    cmu_us_slt_arctic_hts
    cmu_us_awb_arctic_hts
;    cstr_rpx_nina_multisyn       ; restricted license (lexicon)
;    cstr_rpx_jon_multisyn       ; restricted license (lexicon)
;    cstr_edi_awb_arctic_multisyn ; restricted license (lexicon)
;    cstr_us_awb_arctic_multisyn
    ked_diphone
    don_diphone
    rab_diphone
    en1_mbrola
    us1_mbrola
    us2_mbrola
    us3_mbrola
    gsw_diphone  ;; not publically distributed
    el_diphone
    )
  "default-voice-priority-list
   List of voice names. The first of them available becomes the default voice.")

(let ((voices default-voice-priority-list)
      voice)
  (while (and voices (eq voice_default 'no_voice_error))
     (set! voice (car voices))
     (if (assoc voice voice-locations)
         (set! voice_default (intern (string-append "voice_" voice)))
         )
     (set! voices (cdr voices))
     )
  )


(provide 'voices)

LÍNEAS DE CONFIGURACIÓN DEL ARCHIVO DE LENGUAJES (languages.scm)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;                                                                       ;;
;;;                Centre for Speech Technology Research                  ;;
;;;                     University of Edinburgh, UK                       ;;
;;;                       Copyright (c) 1996,1997                         ;;
;;;                        All Rights Reserved.                           ;;
;;;                                                                       ;;
;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
;;;  this software and its documentation without restriction, including   ;;
;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
;;;  permit persons to whom this work is furnished to do so, subject to   ;;
;;;  the following conditions:                                            ;;
;;;   1. The code must retain the above copyright notice, this list of    ;;
;;;      conditions and the following disclaimer.                         ;;
;;;   2. Any modifications must be clearly marked as such.                ;;
;;;   3. Original authors' names are not deleted.                         ;;
;;;   4. The authors' names are not used to endorse or promote products   ;;
;;;      derived from this software without specific prior written        ;;
;;;      permission.                                                      ;;
;;;                                                                       ;;
;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
;;;  THIS SOFTWARE.                                                       ;;
;;;                                                                       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;  Specification of voices and some major choices of synthesis
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;  This should use some sort of database description for voices so
;;;  new voices will become automatically available.
;;;

(define (language_british_english)
"(language_british_english)
Set up language parameters for British English."
  (require 'voices)
  ;;  Will get more elaborate, with different choices of voices in language

  (set! male1 (lambda () (voice_rab_diphone)))
  (set! male2 (lambda () (voice_don_diphone)))
  (if (symbol-bound? 'voice_gsw_diphone)
      (set! male3 voice_gsw_diphone))
  (if (symbol-bound? 'voice_gsw_450)
      (set! male4 voice_gsw_450))

  (male1)
  (Parameter.set 'Language 'britishenglish)
)


(define (language_italian)
"(language_italian)
Set up language parameters for Italian."

  (if (symbol-bound? 'voice_lp_diphone)
      (set! female1 (lambda () (voice_lp_diphone))))
  (set! male1 (lambda () (voice_pc_diphone)))

  (male1)
  (Parameter.set 'Language 'italian)
)


(define (language_american_english)
"(language_american_english)
Set up language parameters for Aemerican English."

  (if (symbol-bound? 'voice_kal_diphone)
      (set! female1 (lambda () (voice_kal_diphone))))
  (set! male1 (lambda () (voice_ked_diphone)))

  (male1)
  (Parameter.set 'Language 'americanenglish)
)

(define (language_finnish)
"(language_finnish)
Set up language parameters for Finnish."
  (if (symbol-bound? 'voice_suo_fi_lj_diphone)
      (set! female1 (lambda () (voice_suo_fi_lj_diphone))))
  (set! male1 (lambda () (voice_hy_fi_mv_diphone)))

  (male1)
  (Parameter.set 'Language 'finnish)
)

(define (language_czech)
"(language_czech)
Set up language parameters for Czech."
   (set! male1 (lambda () (voice_czech_ph)))
   (male1)
   (Parameter.set 'Language 'czech)
)

(define (language_russian)
"(language_russian)
Set up language parameters for Russian."
  (set! male1 voice_msu_ru_nsh_clunits)
  (male1)
  (Parameter.set 'Language 'russian)
)

(define (language_scots_gaelic)
"(language_scots_gaelic)
Set up language parameters for Scots Gaelic."
  (error "Scots Gaelic not yet supported.")

  (Parameter.set 'Language 'scotsgaelic)
)

(define (language_welsh)
"(language_welsh)
Set up language parameters for Welsh."

  (set! male1 (lambda () (voice_welsh_hl)))

  (male1)
  (Parameter.set 'Language 'welsh)
)

(define (language_castillian_spanish)
"(language_spanish)
Set up language parameters for Castillian Spanish."

  ;;(voice_el_diphone)
  ;;(set! male1 (lambda () (voice_el_diphone)))

(voice_JuntaDeAndalucia_es_sf_diphone)
(set! male1 voice_JuntaDeAndalucia_es_sf_diphone)

  (Parameter.set 'Language 'spanish)
)

(define (select_language language)
  (cond
   ((or (equal? language 'britishenglish)
    (equal? language 'english))  ;; we all know its the *real* English
    (language_british_english))
   ((equal? language 'americanenglish)
    (language_american_english))
   ((equal? language 'scotsgaelic)
    (language_scots_gaelic))
   ((equal? language 'welsh)
    (language_welsh))
   ((equal? language 'italian)
    (language_italian))
   ((equal? language 'spanish)
    (language_castillian_spanish))
   ((equal? language 'finnish)
    (language_finnish))
   ((equal? language 'czech)
    (language_czech))
   ((equal? language 'klingon)
    (language_klingon))
   ((equal? language 'russian)
    (language_russian))
   (t
    (print "Unsupported language, using English")
    (language_british_english))))

;;(defvar language_default language_british_english)
(defvar language_default language_castillian_spanish)
(provide 'languages)

Script para enviar totales de tráfico de red vía email

El siguiente código fuente muestra cómo podemos enviar vía email los totales de tráfico de red obtenidos a través del software ipfm (IP Flow-meter). Realizando una correcta configuración de ipfm podemos obtener en un archivo con el formato ipfm-global-YYYY-mm-dd.log el volumen de tráfico generado diariamente (por ejemplo). Estos totales pueden ser volcados a un archivo de texto que constituirá el cuerpo del mensaje de correo electrónico que enviaremos a nuestra cuenta de monitorización.

De manera paralela, a través de este archivo de totales podemos incorporar en nuestro apache un script realizado en php que, tomando los datos de dicho archivo, nos mostrará en formato web lo descargado por los equipos que forman nuestra red. Puedes encontrár más información sobre esto en: http://scripfm.sourceforge.net/

Este es el código fuente:

#!/bin/bash

#Script que envía el estado del log de tráfico de ipfm a través
#de un mensaje de correo electrónico enviado desde la consola

servidor="[nombre del servidor]"
hoy=`date +%Y_%d_%m`
actual=`date +%Y-%m-%d`

if [ -f estadotrafico.txt ]
then
    rm estadotrafico.txt
else
    touch estadotrafico.txt
fi

echo "Subject: Estado del tráfico $servidor" >> estadotrafico.txt
echo
echo
echo "Trafico: $hoy" >> estadotrafico.txt
#Enviamos contenido archivo con totales diarios
cat /var/log/ipfm/ipfm-global-$actual.log >> estadotrafico.txt


sudo ssmtp tudirecciondecorreo@dominio.com < estadotrafico.txt

Ejecución descontrolada de procesos - Bombas FORK

Buscando en Internet información relativa a comandos sobre procesos, he encontrado una información muy interesante sobre la Ejecución descontrolada de procesos en un sistema Linux a través del comando fork.

En definitiva, se trata del clásico problema de ejecución de múltiples procesos que solicitan recursos en un sistema hasta que lo dejan KO. Gracias a los datos aportados en la web Planet Ubuntu, podemos aprender mucho más sobre lo vulnerable que es un sistema operativo. Puedes acceder a toda la información en este enlace: Bombas FORK. o pasándote por el Blog de Vicente Navarro: Fork, ulimit y limits.conf que es la fuente original.

Filtro básico de entrada con CASE

Aquí os dejo un filtro básico de letras realizado con expresiones y la estructura condicional múltiple case-esac.

#!/bin/bash

#Este script implementa un filtro de datos
#a través de expresiones y la estructura
#condicional múltiple case


dato=""
while [ "$dato" == "" ]
do
    read  -p "Introduce una letra mayúscula: " dato
    case $dato in
        [A-Z]) echo "Ok, has introducido la letra $dato";;
        [a-z]) echo "Error, has introducido una minúscula";;
        [0-9]) echo "Error, has introducido un número";;
        *) echo "Error, ¿Qué has introducido?";;
    esac

done

Instalador servicio correo ssmtp para alertas por email

Complementando las entradas de script de instalación y configuración automática de servicios en un servidor, os propongo una posible solución para dotar a un servidor de capacidad para enviar correos electrónicos de alerta a su administrador. Para ello, se realiza la instalación del servicio ssmtp (servicio de correo electrónico simple) y su correspondiente configuración modificando los archivos ssmtp.conf y revaliases, según la configuración que se indique desde teclado.

Para comprobar el correcto funcionamiento del servicio ssmtp, una vez haya sido instalado y configurado desde el script, sólo tendremos que teclear en la consola de comandos algo como esto:

ssmtp dirección_destino@loquesea.com < mensaje.txt

donde mensaje.txt deberá tener un formato adecuado, tal que así:

from: servidor que envia la alerta

subject: asunto de la alerta

# línea en blanco

texto de la alerta, tantas líneas como se necesiten

En este enlace puedes encontrar más información relacionada con el envío y preparación de correos electrónicos a través de consola. Y hacia el final de esta otra entrada podrás encontrar la primera versión de instalación automática del servicio ssmtp y envío de alertas por email.

En próximas entradas de este mismo blog, os mostraremos scripts que construirán mensajes de alerta automáticos en función del servicio/os que puedan haber caído.

#!/bin/bash

#Script que instala y configura servicio
#de correo electrónico ssmtp

#-------------------------------------
#     FUNCIONES
#-------------------------------------

function eresroot()
{
    if [ "$LOGNAME" != "root" ]              
    then
        echo "Este script debe ser ejecutado con privilegios de root."
        exit 1
    fi 
}

function configura()
{

    #1) Saco copia de seguridad
    if [ -f /etc/ssmtp/ssmtp.conf.old ]
    then
        echo "No se sacará copia de seguridad de ssmtp.conf"
    else
        cp /etc/ssmtp/ssmtp.conf /etc/ssmtp/ssmtp.conf.old
    fi

    if [ -f /etc/ssmtp/revaliases.old ]
    then
        echo "No se sacará copia de seguridad de revaliases"
    else
        cp /etc/ssmtp/revaliases /etc/ssmtp/revaliases.old
    fi


    #2) Modifico ssmtp.conf

    read -p "Introduce el usuario de gmail (sin @gmail.com): " usuario_gmail
    read -s -p "Introduce la contraseña: " clave_gmail

    echo "root=$usuario_gmail@gmail.com
mailhub=smtp.gmail.com:587
rewriteDomain=
hostname=$usuario_gmail
AuthUser=$usuario_gmail@gmail.com
AuthPass=$clave_gmail
FromLineOverride=YES
UseSTARTTLS=YES " > /etc/ssmtp/ssmtp.conf

    #3) Modifico revaliases
    echo "root:$usuario_gmail@gmail.com:smtp.gmail.com:587
tu_usuario_linux:$usuario_gmail@gmail.com:smtp.gmail.com:587" >> /etc/ssmtp/revaliases

}

function instala()
{

    which ssmtp
    if [ $? -ne 0 ]
    then
        # Hacemos una instalación silenciosa y sin confirmación
        sudo apt-get install -y -q=2 ssmtp
        if [ $? -eq 0 ]
        then
            echo "Instalación correcta de ssmtp"
            configura
        else
            echo "Error en la instalación de ssmtp"
            exit 1
        fi
    else
        configura   
    fi


}


#-------------------------------------
#     PROGRAMA PRINCIPAL
#-------------------------------------
eresroot
instala

Asistente Jarvis (Shell Script)

En este script podemos ver cómo integrar un software de sintetización de voz y hacer que reproduzca lo que deseemos. Se trata de un asistente que emite a través del comando espeak todo aquel texto que se le pase como parámetro. Según vamos escribiendo el asistente lo va emitiendo a través del sistema de audio del equipo. Es un ejercicio sencillo que puede servirnos para practicar el uso de parámetros.

#!/bin/bash

#Asistente Jarvis
clear

#Preconfiguramos el tono, velocidad y demás elementos 
#relacionados con el comando espeak, para que la voz de nuestro
#asistente se entienda adecuadamente.
 
parametros="-v es -s 150 -p45"
 

echo "ASISTENTE DE CONVERSACIÓN: JARVIS"
mensaje_bienvenida="Bienvenido al asistente de conversación digital: Jarvis"
 
espeak $parametros "$mensaje_bienvenida" 2>/dev/null
 
frase="Escribe tus mensajes a continuación"
 
espeak $parametros "$frase" 2>/dev/null

#Preparamos un bucle infinito que solicitará 
#contínuamente la introducción de cualquier texto
#para que sea reproducido. Podremos parar con Ctrl+C 
#La salida del programa debería mejorarse.

while [ 1 ]
do   
   
    read -p "Texto a emitir (* para salir): " texto
    if [ "$texto" == "*" ]
    then
         break
    else
         espeak $parametros "$texto" 2>/dev/null
    fi   
done
echo "Gracias por utilizar este software"
espeak $parametros "Gracias por utilizar este software"

exit 0

Script para automatizar la instalación de Webmin

A continuación os propongo un Shell Script que automatiza la instalación de Webmin para Linux en su versión 1.670. Webmin permite, entre otras cosas: gestionar múltiples servicios de un servidor, modificar la configuración del sistema y otras muchas utilidades que a un administrador de sistemas le pueden facilitar el trabajo diario con sus servidores Linux.

La mayor ventaja es que Webmin permite todas estas acciones a través de un navegador web, concretamente con la utilización del puerto 10000.

Pues bien, este código fuente intenta comprobar la existencia de Webmin en el servidor, si existe lo actualiza y si no existe procede a su descarga e instalación. Finalmente, se eliminan los archivos temporales utilizados.

Es interesante observar que los mensajes al usuario que el propio script muestra en pantalla, han sido destacados mediante letra en negrita. Esto se consigue utilizando unos patrones para el formateo del texto emitido con la orden echo. Aquí teneis un enlace para tener más información sobre Colores en Shell Scripts.

#!/bin/bash

#Script que automatiza la instalación de webmin en su versión 1.670
#Creación: 29/01/2014
#Variables para poner letra en negrita
abrenegrita="\033[1m"
cierranegrita="\033[0m"


if [ $LOGNAME != "root" ]
then
    echo -e "$abrenegrita Lo siento, este script requiere ejecutarse con privilegios de root. $cierranegrita"
    read
    exit 1
fi

#Comprobamos si Webmin está instalado
if [ -f /etc/init.d/webmin ]
then
    echo -e "$abrenegrita Webmin se encuentra instalado en su sistema. $cierranegrita"
    version=`cat /etc/webmin/version`   
    echo -e "$abrenegrita Versión actual: $version $cierranegrita "
else
    echo -e "$abrenegrita Webmin no se encuentra instalado en su sistema, procediendo a la instalación... $cierranegrita"
fi

#Comprobamos si está instalado aptitude
which aptitude > /dev/null
if [ $? -ne 0 ]
then
    apt-get install aptitude   
fi
#Instalamos los paquetes previos necesarios para Webmin
aptitude install perl libnet-ssleay-perl openssl libauthen-pam-perl libpam-runtime libio-pty-perl apt-show-versions
if [ $? -eq 0 ]
then
    echo -e "$abrenegrita Instalación satisfactoria de paquetes adicionales necesarios para webmin.$cierranegrita"
else
    echo -e "$abrenegrita Error en la instalación de paquetes necesarios para webmin.$cierranegrita"
    echo -e "$abrenegrita El script se cerrará.$cierranegrita"
    read
    exit 1
fi

#Descargamos en la carpeta tmp el paquete deb de instalación de webmin
#para ello creamos una carpeta específica

if [ -d /tmp/descarga_webmin ]
then
    echo -e "$abrenegrita Descargando...$cierranegrita"
else
    mkdir /tmp/descarga_webmin
fi

if [ $? -eq 0 ]
then
    cd /tmp/descarga_webmin
    #nos posicionamos en la nueva carpeta temporal y descargamos webmin
    wget http://prdownloads.sourceforge.net/webadmin/webmin_1.670_all.deb   
else
    echo -e "$abrenegrita Error en la descarga del paquete .deb de webmin.$cierranegrita"
    echo -e "$abrenegrita El script se cerrará.$cierranegrita"
    read
    exit 1
fi

if [ -f /tmp/descarga_webmin/webmin_1.670_all.deb ]
then
    echo -e "$abrenegrita El paquete webmin en su versión 1.670 existe, instalando...$cierranegrita"
    dpkg -i webmin_1.670_all.deb
    if [ $? -eq 0 ]
    then
        echo -e "$abrenegrita Instalación satisfactoria, pulsa una tecla para comprobar...$cierranegrita"
        firefox -new-window https://localhost:10000
    else
        echo -e "$abrenegrita Error al instalar webmin.$cierranegrita"
        echo -e "$abrenegrita El script se cerrará.$cierranegrita"
        read
        exit 1
    fi
else
    echo -e "$abrenegrita El paquete .deb no se encuentra en la ubicación predeterminada.$cierranegrita"
    echo -e "$abrenegrita Imposible instalar webmin.$cierranegrita"
    echo -e "$abrenegrita El script se cerrará.$cierranegrita"
    read
    exit 1
fi

#Eliminamos la carpeta temporal y el archivo descargado
respuesta=""

while [ "$respuesta" == "" ]
do
    read -p "¿Desea eliminar los archivos temporales utilizados en la instalación? (S/N)" respuesta
    case $respuesta in
        s|S) rm -r /tmp/descarga_webmin;break;;   
        n|N) echo "Ok, se mantendrán en /temp/descarga_webmin";break;;
        *)echo "No ha introducido una respuesta válida";;
    esac
done

echo -e "$abrenegrita Fin del Script. $cierranegrita"
read -p "Pulse una tecla."
exit 0

Script para configuración de IP estática

El siguiente código fuente corresponde a un script cuyo objetivo es permitir la configuración de una única interfaz de red en una máquina Linux.

Hay que decir que el script no ha sido completado ya que se utilizó para comenzar las explicaciones relacionadas con la configuración de red de máquinas Linux y recordatorio de shellscripts. Dada la posible complejidad que pudiera derivarse al intentar dotar a este script de capacidad para configurar más de un interfaz de red, se optó por hacerlo para una sola.

Debemos tener en cuenta que si estamos trabajando con cualquier distro cuya gestión de interfaces de red esta realizada a través de Network Manager, será necesario desactivar dicho sistema de gestión.

Para ello bastaría con acceder al archivo de configuración de NetworkManager (/etc/NetworkManager/NetworkManager.conf) en la máquina en cuestión y poner a "false" la variable "managed". Si tienes alguna duda al respecto, te aconsejo que accedas al siguiente enlace: Desactivación de NetworkManager en Ubuntu.

Aquí teneis el código fuente:

#!/bin/bash

#Script que permite configurar de manera estática el direccionamiento IP
#de una tarjeta de red en una máquina Ubuntu Desktop 12.04.
#Para que los no nos afecte el gestor de red NetworkManager de Ubuntu
#deberemos desactivarlo. Accederemos a /etc/NetworkManager/NetworkManager.conf
#lo editaremos y modificaremos la variable "managed" poniéndola a false.

#los archivos a tener en cuenta en este script serían:
#a) Configuración IP: /etc/network/interfaces
#b) Resolución de nombres WAN: /etc/resolv.conf
#c) Resolución de nombre LAN: /etc/hosts (opcional)

#--------------------
# FUNCIONES
#--------------------

function titulo()
{
    clear
    echo "****************************************************"
    echo "*   CONFIGURADOR DE DIRECCIONAMIENTO IP ESTÁTICO   *"
    echo "****************************************************"
}

function copiaseg()
{
          
    echo "Realizando copias de seguridad..."
   
    if [ -f /etc/network/interfaces ]
    then
        cp /etc/network/interfaces /etc/network/interfaces.original
        if [ $? -eq 0 ]
        then
            echo "El archivo interfaces ha sido salvaguardado con éxito."
        else
            echo "Error al salvaguardar el archivo interfaces."
        fi
    fi

    if [ -f /etc/resolv.conf ]
    then
        cp /etc/resolv.conf /etc/resolv_original.conf
        if [ $? -eq 0 ]
        then
            echo "El archivo resolv.conf ha sido salvaguardado con éxito."
        else
            echo "Error al salvaguardar el archivo resolv.conf."
        fi
    fi
   
}


function grabar_configuracion()
{

    echo "----------------------------------------------------"
    echo "La nueva configuración de red introducida es: "
    echo "Interfaz: $1"
    echo "Dirección IP: $2"
    echo "Máscara de red: $3"
    echo "Puerta de enlace / Gateway: $4"
    echo "DNS 1º: $5"
    echo "DNS 2º: $6"
    echo "----------------------------------------------------"

    # A partir de aquí abría que reescribir completos los archivos    
    # de configuración interfaces y resolv.conf
   
   
    #Modificación de /etc/network/interfaces
    interfaces="/etc/network/interfaces"
    echo "auto lo" > $interfaces
    echo "iface lo inet loopback" >> $interfaces
    echo "auto $1" >> $interfaces
    echo "iface $1 inet static" >> $interfaces
    echo "address $2" >> $interfaces
    echo "mask $3" >> $interfaces
    echo "gateway $4" >> $interfaces

    #Modificación de /etc/resolv.conf
    resolv="/etc/resolv.conf"   
    echo "#Generado por script configuraip.sh" > $resolv
    echo "nameserver $5" >> $resolv
    echo "nameserver $6" >> $resolv

    #reiniciamos los servicios de red para
    #que la nueva configuración tenga efecto
    /etc/init.d/networking restart

}



#--------------------
# PROGRAMA PRINCIPAL
#--------------------

titulo

if [ $LOGNAME != "root" ]
then
    read -p "Lo siento, este script debe ser ejecutado con privilegios de root."
    exit 1   
fi

#Mostramos los interfaces de red
titulo
echo "Mostrando interfaces de red actuales..."
for nic in `lshw -short -class network | grep eth | tr -s " " | cut -f2 -d" " `
do
    echo "* Interfaz: $nic"
done
echo "-----------------------------------------------------"

nic_elegida=""
while [ "$nic_elegida" == "" ]
do
    read -p "Elige la interfaz que deseas configurar: " nic_elegida
done

nic_valida=1
for nic in `lshw -short -class network | grep eth | tr -s " " | cut -f2 -d" " `
do
    if [ $nic == $nic_elegida ]
    then
        nic_valida=0
    fi
done

if [ $nic_valida -ne 0 ]
then
    echo "Error, la interfaz $nic_elegida no es válida."
    read -p "Pulsa una tecla para cerrar el script..."
    exit 1
fi


echo "La interfaz elegida es: $nic_elegida"
read -p "Introduce la nueva dirección ip estática: " ip
read -p "Introduce la nueva máscara de red: " mascara
read -p "Introduce la puerta de enlace: " puerta
read -p "Introduce el DNS 1º: " dns1
read -p "Introduce el DNS 2º: " dns2
echo
read -p "Pulse una tecla para continuar."
titulo

respuesta=""
while [ "$respuesta" == "" ]
do
    read -p "Desea grabar estos datos de configuración (S/N): " respuesta
    case $respuesta in
        s|S)copiaseg; grabar_configuracion $nic_elegida $ip $mascara $puerta $dns1 $dns2;            break;;
        n|N)echo "Ok, no se modificarán los archivos de configuración"; read; break;;
        *) echo "No ha introducido una respuesta válida, vuelva a intentarlo.";;
    esac
done

echo "Fin del script."
read
exit 0

Tweets desde consola de comandos Linux (twidge y TTYtter)

Twidge y TTYtter son dos alternativas muy útiles para enviar tweets desde la terminal de comandos.

En un post anterior os ofrecía una guía para poder enviar correos electrónicos desde la consola de comandos de GNU/Linux (Ubuntu). Concretamente a través del servidor ssmtp. En esta ocasión vamos a ver qué tenemos que hacer para poder enviar Tweets desde una Shell.

El objetivo del envío de estos Tweets es recopilar en un hastag mensajes de monitorización de los servidores que pudiera tener a su cargo un administrador de sistemas. Estos Tweets, al ser cortos y muy concretos en su información, pueden ofrecer una visión rápida del estado de los servidores o alertas que tengamos configuradas en ellos.

Manos a la obra. La primera herramienta que vamos a utilizar se denomina Twidge y para instalarla/configurarla haremos lo siguiente:

1) Actualiza tu sistema Ubuntu mediante un: 

sudo apt-get update

2) Realiza la instalación de Twidge:

sudo apt-get install twidge

3) Una vez instalado, debemos proceder con la configuración básica de Twidge:

sudo twidge setup

Al lanzar este comando, se nos mostrará en pantalla una URL que deberemos copiar y pegar en nuestro navegador web. Seguidamente, el programa de configuración de Twidge queda a la espera de la introducción de un código numérico.

Este código numérico lo obtendremos siguiendo las indicaciones que se marcan en la URL indicada anteriormente. Una vez en la página correspondiente a dicha dirección, deberemos hacer un login con nuestro usuario y contraseña de Twitter para autorizar a Twidge el uso de dicha cuenta, de cara al envío de Tweets. Después de hacer login, se mostrará el código numérico que debemos ingresar en la línea de comandos, para finalizar correctamente la instalación de Twidge.

Ya estaríamos preparados para empezar a enviar Tweets a través de consola. Para ello utilizaríamos el siguiente formato:

twidge update 'Texto a enviar - máximo 140 caracteres'

Si necesitamos obtener algo más de información sobre las opciones de twidge podemos teclear:

man twidge
twidge lscommands

Por cierto, es muy recomendable que accedas a tu cuenta en Twitter y edites las preferencias de tu cuenta para modificar la seguridad de tus envíos y la forma en la que pueden seguir tus Tweets el resto de usuarios de Twitter, tú mismo.

Ahora ya solo quedaría generar Shell Scripts en GNU/Linux que sean capaces de recopilar información interesante para un administrador de sistemas y enviarla vía Twitter a tu cuenta para mantenerte informado al momento. Espero que en próximas entregas podamos ver el código fuente de algún script que haga algo relacionado.

En segundo lugar, analizaremos el uso alternativo de TTytter, ya que es posible que al intentar enviar los tweets con twidge en Ubuntu 12 os genere algún error 410 de usuario no autorizado. Este error se produce por una modificación que se realizó en la API de twitter y que dejó a twidge fuera de combate, si lo quieres ejecutar en un Ubuntu 12. Para resolver esto tendreis que seguir el siguiente enlace y realizar los pasos que os indica: Instalación y configuración de TTYtter para envío de tweets bajo terminal de comandos mediante TTYtter. Otros enlaces relacionados que pueden ser interesantes son estos: posible alternativa a twidge, TTYtter.

Yo he probado TTYtter desde consola de comandos y ha bastado con escribir esto en la terminal para recibir correctamente los tweets.

ttytter -status="Este es un mensaje de prueba desde TTYtter"
(Ojo, primero debes autorizar a TTYtter, pero esto lo podeis hacer desde el enlace que os he pasado más arriba.)