El primer corto de Julito(Mi hijo)!

Archivos de configuracion de FreeSWITCH

Esto se basa en lo publicado en este blog

FreeSWITCH es configurado en base ha archivos XML, los cuales se encuentran  ubicados por defecto en la carpeta conf del directorio de FreeSWITCH. ejemplo:

/usr/local/freeswitch/conf/

En la carpeta conf tendremos como principales archivos de configuracion los siguientes:

freeswitch.xml

Es el archivo maestro de la configuración de FreeSWITCH, éste incluye los demas archivos de configuración convirtiéndose en el punto de entrada en la carga de la configuración y pre-procesamiento de variables.

vars.xml

Define variables globales al sistema que pueden ser accedidas desde un plan de marcación, este archivo contiene algunas líneas con la marca especial X-PRE-PROCESS, estas líneas no pueden ser comentados.

La sintaxis usada para definir una variable es:



El valor de una variable previamente definida se obtiene así:

${nombre_variable} o $${nombre_variable}

La diferencia entre $ y $$ es el tipo de acceso, con $ el valor se obtiene
cuando se usa la variable, con $$ se maneja como valor de pre-procesador y se obtiene durante la carga de FreeSWITCH o se recarga la configuración del archivo freeswicth.xml con el comando relaodxml. La diferencia básica es que el valor con $ es expandido en el uso mientras con $$ es expandió en la carga del sistema.

base_dir: define el directorio raíz donde se ejecuta FreeSWITCH
sound_prefix: define el direcotrio donde se encuentran los archivos de audio (esta variable esta en revisión todavia aunque se usa en la actualidad)
local_ip_v4: dirección IP local, esta variable la define automáticamente FreeSWITCH
domain: define el dominio por defecto para identificar las extensiones registradas, asignado por defecto como $${local_ip_v4}
global_codec_prefs: codecs disponibles para la negociación con las extensiones registradas
outbound_codec_prefs: ocedecs disponibles para la negociación con gateways
outbound_caller_name: este nombre se usa para mostrarlo en el teléfono cuando se hace una llamada
outbound_caller_id: número usado para mostrarlo en el teléfono cuando se hace una llamada

dialplan/

Los planes de marcación se definen en el directorio dialplan, esto lo veremos en mas detalle en otra entrada del blog.

directory/

Las extensiones que pueden registrarse con FreeSWITCH se encuentran en el directorio directory, esto lo veremos en mas detalle en otra entrada del blog.

autoload_configs/

  El directorio autoload_configs contiene los archivos de configuración basicos de FreeSWITCH y  de los distintos modulos se utilizar por FreeSWITCH como pueden ser el call center, lua, etc

modules.conf.xml

Este archvio determina que módulos se van a carga durante el inicio de FreeSWITCH

sofia.conf.xml

Archivo de configuración para definiciones SIP

Instalacion de FreeSWITCH en Ubuntu

Introducción

FreeSWITCH es uno de los mejores proyectos de comunicaciones de código abierto que hay en la actualidad, como lo describen en su sitio oficial http://www.freeswitch.org/

“FreeSWITCH is an open source telephony platform designed to facilitate the creation of voice and chat driven products scaling from a soft-phone up to a soft-switch. It can be used as a simple switching engine, a PBX, a media gateway or a media server to host IVR applications using simple scripts or XML to control the callflow.”

FreeSWITCH (escribiendo SWITCH en mayúscula) es una plataforma de telefonía de código abierto diseñada para facilitar la creación de productos de voz y chat escalando desde un soft-phone hasta un soft-switch. Puede ser usado como un motor de conmutación, una PBX, un media Gateway o un servidor de medios (media server) para alojar aplicaciones de IVR usando simples scritps o archivos XML para el control de flujo de la llamada.

En otras palabras FreeSWITCH se puede comportar como un simple soft-phone, una PBX o en realidad un soft-switch, por ello el campo de aplicación de esta plataforma resulta tan interesante.

Otra característica importante para los usuarios y programadores del mundo Windows es que puede ser construido y correr nativamente sobre Windows, también sobre Linux, Mac OS, BSD y Solaris tanto para 32 como para 64 bits (http://wiki.freeswitch.org/wiki/Specsheet).

 

 Instalación de dependencias

Se deben instalar las dependencias necesarias para poder compilar FreeSWITCH, para esto se utilizara el sistema de gestión de paquetes de Ubuntu, aptitude.

sudo aptitude install git-core build-essential autoconf automake libtool libncurses5 /
libncurses5-dev make libjpeg-dev pkg-config unixodbc unixodbc-dev zlib1g-dev 

sudo apt-get install libcurl4-openssl-dev libexpat1-dev libssl-dev /
libtiff4-dev libx11-dev unixodbc-dev python-dev zlib1g-dev /
 libzrtpcpp-dev libasound2-dev libogg-dev libvorbis-dev libperl-dev  / 
libgdbm-dev libdb-dev python-dev uuid-dev bison

Descarga de FreeSWITCH e instalación

Para compilar la ultima versión estable de FreeSWITCH se deben descargas las fuentes vía la aplicación GIT. La FreeSWITCH debe descargarse en la carpeta /usr/src/ , que esta carpeta estándar para códigos fuentes.

 #ingresamos a la carpetas de códigos
 cd /usr/src
#DescargamosFreeSWITCH
git clone -b v1.2.stable git://git.freeswitch.org/freeswitch.git
#Ingresamos a la carpeta descargada
cd freeswitch/ 
# ejecutamos el bootstarp
./bootstrap.sh

Ahora se definirán los módulos que son necesarios compilar en FreeSWITCH, esto se

realiza en el archivo modules.conf, usando el editor NANO para realizar los cambios.

nano modules.conf


Se deben descomentar las siguientes lineas como ejemplo:

applications/mod_spy
languages/mod_python
say/mod_say_es



Echo esto comenzamos con los pasos de compilación.

./configure # comando que verifica dependencias
make # este comando compila FreeSWITCH
make install # aquí instalamos los archivos compilados
make uhd-moh-install # descargamos la musica de espera
make samples # instala las configuraciones por defecto

Con estos pasos FreeSWITCH esta instalado en la carpeta /usr/local/freeswitch/.

Necesitamos realizar los últimos pasos de instalación, que son crear los accesos directos,crear el archivo init de arranque y definir que freeswitch arranque al iniciar el servidor.

ln -s /usr/local/freeswitch/bin/fresswitch /usr/bin/
ln -s /usr/local/freeswitch/bin/fs_cli /usr/bin/
creamos el archivo de inicio de FreeSWITCH

nano /etc/init.d/freeswitch

e insertamos el contenido del archivo puesto freeswitch.init al final  y cambiamos los permisos del archivo creado

chmod +x /etc/init.d/freeswitch

Incluimos el archivo recién creado en la lista de arranque del Sistema Operativo

update-rc.d -f freeswitch defaults

Verificación de instalación

Para realizar la verificación de la instalación de FreeSWITCH se debe arrancar este

manualmente a través del siguiente comando

freeswitch

Si todo funciona bien deberías entrar a la consola de FreeSWITCH

FreeSWITCH Started
Max Sessions [1000]
Session Rate [30]
SQL [Enabled]
freeswitch@ubuntu-server>

Dentro de la consola ejecutar el comando shutdown para salir y parar FreeSWITCH.
Para el inicio y arranque estándar de FreeSWITCH de usar los siguientes comandos.


/etc/init.d/freeswitch start
/etc/init.d/freeswitch stop




Archivo freeswitch.init

#!/bin/bash
### BEGIN INIT INFO
# Provides:          freeswitch
# Required-Start:    $local_fs $remote_fs
# Required-Stop:     $local_fs $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       Freeswitch debian init script.
# Author: Matthew Williams
#
### END INIT INFO
# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/bin
DESC="Freeswitch"
NAME=freeswitch
DAEMON=/usr/local/freeswitch/bin/$NAME
DAEMON_ARGS="-nc"
PIDFILE=/usr/local/freeswitch/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

FS_USER=root
FS_GROUP=daemon

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions

#
# Function that sets ulimit values for the daemon
#
do_setlimits() {
        ulimit -c unlimited
        ulimit -d unlimited
        ulimit -f unlimited
        ulimit -i unlimited
        ulimit -n 999999
        ulimit -q unlimited
        ulimit -u unlimited
        ulimit -v unlimited
        ulimit -x unlimited
        ulimit -s 240
        ulimit -l unlimited
        return 0
}

#
# Function that starts the daemon/service
#
do_start()
{
        # Set user to run as
        if [ $FS_USER ] ; then
          DAEMON_ARGS="`echo $DAEMON_ARGS` -u $FS_USER"
        fi
        # Set group to run as
        if [ $FS_GROUP ] ; then
          DAEMON_ARGS="`echo $DAEMON_ARGS` -g $FS_GROUP"
        fi

        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started
        start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null -- \
                || return 1
        do_setlimits
        start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
                $DAEMON_ARGS \
                || return 2
        # Add code here, if necessary, that waits for the process to be ready
        # to handle requests from services started subsequently which depend
        # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
        # Return
        #   0 if daemon has been stopped
        #   1 if daemon was already stopped
        #   2 if daemon could not be stopped
        #   other if a failure occurred
        start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
        RETVAL="$?"
        [ "$RETVAL" = 2 ] && return 2
        # Wait for children to finish too if this is a daemon that forks
        # and if the daemon is only ever run from this initscript.
        # If the above conditions are not satisfied then add some other code
        # that waits for the process to drop all resources that could be
        # needed by services started subsequently.  A last resort is to
        # sleep for some time.
        start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
        [ "$?" = 2 ] && return 2
        # Many daemons don't delete their pidfiles when they exit.
        rm -f $PIDFILE
        return "$RETVAL"
}

#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
        #
        # If the daemon can reload its configuration without
        # restarting (for example, when it is sent a SIGHUP),
        # then implement that here.
        #
        start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
        return 0
}

case "$1" in
  start)
        [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
        do_start
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  stop)
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
        do_stop
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  #reload|force-reload)
        #
        # If do_reload() is not implemented then leave this commented out
        # and leave 'force-reload' as an alias for 'restart'.
        #
        #log_daemon_msg "Reloading $DESC" "$NAME"
        #do_reload
        #log_end_msg $?
        #;;
  restart|force-reload)
        #
        # If the "reload" option is implemented then remove the
        # 'force-reload' alias
        #
        log_daemon_msg "Restarting $DESC" "$NAME"
        do_stop
        case "$?" in
          0|1)
                do_start
                case "$?" in
                        0) log_end_msg 0 ;;
                        1) log_end_msg 1 ;; # Old process is still running
                        *) log_end_msg 1 ;; # Failed to start
                esac
                ;;
          *)
                # Failed to stop
                log_end_msg 1
                ;;
        esac
        ;;
  *)
        #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
        echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
        exit 3
        ;;
esac

Usar Web2py con servidor web embebido

En muchas situaciones podría ser útil utilizar Web2py sin un servidor web como Apache o Nginx, ya que no va haber mucha concurrencia de usuarios o por otros motivos, aqui les mostrare los pasos necesarios para realizar esto.

1.- Instalar Web2py

Esto lo puedes ver en http://cabildocl.blogspot.com/2013/12/instalacion-minima-de-web2py.html

2.- Crear certificados para utilizar HTTPS

Web2py no permite ingresar a la aplicacion admin si no es por HTTPS y para eso necesitamos generar las claves privadas y los certificados.

Generar clave privada

openssl genrsa -out server.key 2048

Creamos el certificado

openssl req -new -key server.key -out server.csr

Después auto firmamos el certificado

openssl x509 -req -day 3650 -in server.csr -signkey server.key -out server.crt


Ahora podemos arrancar web2py con el certificado creado

python web2py.py -c server.crt -k server.key --ip=0.0.0.0

Con esto podras entrar de manera remota a la administracion de web2py sin necesidad de servidor web externo.

Bonus

Como regalo les dejo un script simple que les permite controlar el arranque de web2py. Deben copiarlo en /etc/init.d/


 #! /bin/sh
# Script de inicio y arranque de web2py

case "$1" in
  start)
    echo "Starting web2py"
    # run application you want to start
    python /web2py/web2py.py -c server.crt -k server.key --ip=0.0.0.0 -a password &
    ;;
  stop)
    echo "Stopping web2py"
    # kill application you want to stop
    pkill -9 -f web2py
    ;;
  *)
    echo "Usage: /etc/init.d/web2py {start|stop}"
    exit 1
    ;;
esac

exit 0

Instalacion minima de Web2py

Esta entrada mostrara como instalar y arrancar Web2py  con 5 simples pasos:

Paso 1: Instalar dependencias

sudo apt-get install python psycopg2   


Paso 2: Descargar fuentes

wget http://www.web2py.com/examples/static/web2py_src.zip


Paso 3: Descomprimir archivos

unzip web2p_src.zip 


Paso 4: Ingresar a la carpeta

cd web2py


Paso 5: Arrancar Web2py

python web2py.py

Ya estamos corriendo web2py!

 

Definir seleccion por defecto en Grub2

Hace poco estábamos en la instalación un FreeSWITCH y una tarjeta E1 Sangoma, nos sucedió el problema de que los dirver Sangoma no eran compatible con el kernel 3.8 de Ubuntu Server 12.04. Después de varias pruebas estos drivers si funcionaron con el kernel 3.5 pero teniamos la problemtica que el servidor arrancaba por defecto con el kernel 3.8, asi que dimos con esta solucion.  


Definir Kernel en Grub2 


El primer paso es ver el menu con el siguiente comando

fgrep menuentry /boot/grub/grub.cfg 

nos mostrara todas las entradas en el menu de grub como la siguiente imagen

Seleccionamos y copiamos una entrada con la que muestra el ejemplo: 'Ubuntu, with Linux 3.2.0-31-generic'

Despues necesitamos editar el siguiente archivo:  

nano /etc/default/grub 

Y editamos las siguiente linea

GRUB_DEFAULT=0

y la dejamos asi

GRUB_DEFAULT='2>Ubuntu, with Linux 3.2.0-31-generic'

Nota: la opcion 2> le dice a grub que utilice el submenu entras anteriores de linux


Realizado esto necesitamos actualizar el kernel y esto lo realizamos con  el comando

update-grub

Y ya podemos probar lo realizado reiniciando la maquina.