Explorando node y express – parte 1

En la actualidad las aplicaciones web están tomando un enfoque mas amplio al controlar desde el servidor web hasta el contenido final que es servido al usuario final, node la plataforma construida en el runtime javascript de chrome permite la rápida construcción de aplicaciones usando un modelo de no bloqueo en I/O y basado en eventos hacen de la plataforma ideal para aplicaciones web escalables, aplicaciones de redes y aplicaciones con cargas de datos intensivas en tiempo real haciendo uso de base de datos nosql como MongoDB, CouchDB, Riak.

Node.js es una plataforma en la cual se han desarrollado muchos componentes que en conjunto brindan toda la funcionalidad necesaria para construir aplicaciones web, como es connect un framework middleware para node, express framework para aplicaciones web, jade

Para este articulo lo primero sera instalar node y el framework express

node esta disponible para todas las plataformas Windows(instaladores para 32 y 64 bits), Linux, Solaris, FreeBSD, Darwin en codigo fuente para compilar e instalar.

Una vez instalado node tenemos acceso al gestor de modulos npm y podremos instalaremos express
express se puede configurar de 2 maneras.

la primera opcione es crear un directorio con un descriptor para la aplicación, un archivo
package.json y luego ejecutar la instalación del modulo express con npm

$ mkdir ndemo
$ cd ndemo
$ vim package.json
$ npm install 
$ npm ls

Descriptor de la aplicacion: package.json

// file: package.json
{
    "name":"ndemo",
    "version":"0.0.1",
    "private":true,
    "scripts":{
        "start":"node app"
    },
    "dependencies":{
        "express":"3.x",
        "jade":"*",
        "stylus":"*"
    }
}

la otra alternativa es instalar express de manera global usando npm y utilizar el comando express para crear la aplicación.

# requiere permisos de root
$ npm install -g express
$ express -s -c stylus ndemo

al final se tendrá el directorio de la aplicación con los módulos necesarios como se muestra en la imagen usando “npm ls” se pueden ver las dependencias de express en la aplicación

npm ls

Con la primera opción se debe crear el script de inicio y del servidor para arrancar la aplicación, con la segunda opción estos archivos son creados automáticamente.

Consumir web services SOAP facil con Python Suds

Suds es un tremendo cliente SOAP para consumir web services es basado en Python a diferencia de los clientes en Java no hay generación de clases, y el API es tipo orientado a objetos. Y lo mejor es el poco código que se debe escribir para consumir un servicio web y para muestra un ejemplo sencillo:

Lo primero instalar el cliente ya sea descargándolo del sitio o instalando el paquetes si nuestra distribución de linux lo incluye en sus repositorios.

# fedora 15
yum -y install python-suds
# tarball
wget https://fedorahosted.org/releases/s/u/suds/python-suds-0.4.tar.gz
tar xzvf python-suds-0.4.tar.gz
cd python-suds-0.4
python setup.py install

Para el ejemplo utilizaremos uno de los webservices del sitio webservicesx.net

#!/usr/bin/env python

from suds.client import Client
url = 'http://www.webservicex.net/globalweather.asmx?WSDL'
client = Client(url)
print client

si todo esta correcto la salida del script mostrara esto:

web service output

Suds ( https://fedorahosted.org/suds/ )  version: 0.3.9 GA  build: R659-20100219

Service ( GlobalWeather ) tns="http://www.webserviceX.NET"
   Prefixes (0)
   Ports (2):
      (GlobalWeatherSoap)
         Methods (2):
            GetCitiesByCountry(xs:string CountryName, )
            GetWeather(xs:string CityName, xs:string CountryName, )
         Types (0):
      (GlobalWeatherSoap12)
         Methods (2):
            GetCitiesByCountry(xs:string CountryName, )
            GetWeather(xs:string CityName, xs:string CountryName, )
         Types (0):

El servicio web tiene 2 metodos los cuales podemos invocar de la siguiente manera:

#!/usr/bin/env python

from suds.client import Client
url = 'http://www.webservicex.net/globalweather.asmx?WSDL'
client = Client(url)
#print client
weather =  client.service.GetWeather('Managua', 'Nicaragua')
print weather

esto generara un string conteniendo el xml para que luego pueda ser procesado según se requiera .

<?xml version="1.0" encoding="utf-16"?>
<CurrentWeather>
  <Location>Managua A. C. Sandino, Nicaragua (MNMG) 12-09N 086-10W 56M</Location>
  <Time>Jul 18, 2011 - 12:00 AM EDT / 2011.07.18 0400 UTC</Time>
  <Wind> from the ESE (110 degrees) at 5 MPH (4 KT):0</Wind>
  <Visibility> greater than 7 mile(s):0</Visibility>
  <SkyConditions> partly cloudy</SkyConditions>
  <Temperature> 77 F (25 C)</Temperature>
  <DewPoint> 73 F (23 C)</DewPoint>
  <RelativeHumidity> 88%</RelativeHumidity>
  <Pressure> 29.88 in. Hg (1011 hPa)</Pressure>
  <Status>Success</Status>
</CurrentWeather>

Referencias:

Python Suds

Zend Framework Shared Hosting

Por lo general cuando desarrollo una aplicación usando Zend Framework esta es desplegada en servidores compartidos donde no es posible realizar una configuración de virtual host en Apache. por lo que utilizo una estructura diferente para la aplicacion

home
|-- [account]
    |-- zend_apps
    |    |-- mobile
    |        |-- application
    |        |-- docs
    |        |-- library
    |        `-- test
    `-- zf
    |   `-- library
    `-- public_html
        `-- mobile
            |-- css
            |-- img
            |-- js
            |-- index.php
            `-- .htaccess

de tal modo que las aplicaciones quedan dentro del directorio “zend_apps”, las librerías del framework en “zf” y los archivos que seran publicos(hojas de estilo, imagenes y javascript) en un folder dentro del directorio raiz del sitio o si se requiere en el mismo directorio raiz “public_html” y solo se modifica el index.php y el archivos .htaccess para corregir las rutas.

<?php
// file: index.php

$apps_path = getenv('ZendApps');  // applications path
$zf_libs = getenv('ZFpath'); // Zend Framework libs path

defined('APPLICATION_PATH')
|| define('APPLICATION_PATH', $apps_path . DIRECTORY_SEPARATOR . 'mobile/application');

// Define application environment
defined('APPLICATION_ENV')
|| define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));

// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(
                                              realpath(APPLICATION_PATH . '/../library'),
                                              realpath($zf_libs . '/library'),
                                              get_include_path(),
                                         )));

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
        APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
        ->run();

Para que los cambios funcionen es necesario agregar variables de entorno en el htaccess utilizando las directivas del modulo de Apache mod_env en el cual debe estar habilitado en el servidor y tendremos un htaccess como este:

# htaccess
SetEnv ZendApps "/home/username/zend_apps"
SetEnv ZFpath "/home/username/zf"
SetEnv APPLICATION_ENV "production"
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ index.php [NC,L]

con este cambio la aplicacion funcionara correctamente y no es necesario configurar un virtual host.

Android SDK en Fedora 14 x86-64

El SDK de Android esta hecho para 32bits para ponerlo a funcionar en Fedora 14 x86-64(64 bits) y correr el emulador usando el JDK de 64 bits requiere instalar librerias de 32 bits; accediendo como usuario root instalamos lo siguiente:

su -
yum install ncurses-libs.i686 libstdc++.i686 glibc.i686 libX11-devel.i686  \
glibc.i686 SDL.i686 libX11.i686 libXext.i686 libao.i686  alsa-lib.i686 -y

Descargamos el SDK del sitio de Android http://developer.android.com/sdk/index.html

Linux (i386) |  android-sdk_r10-linux_x86.tgz |  26981997 bytes |  c022dda3a56c8a67698e6a39b0b1a4e0

descomprimimos el archivos, desde la terminal ejecutamos

cd android-sdk-linux_x86/tools
./android

descargamos el SDK con la version del API que vayamos a utilizar y listo solo queda configurar el dispositivo y probarlo.

El dispositivo puede crearse desde la consola o desde la aplicacion grafica.

# creando el dispositivo desde la consola
cd android-sdk-linux_x86/tools
./android  create avd -c 256M -t 1 -n android_223 -a -s WQVGA400 --force

al igual el emulador se puede arrancar desde la consola o la aplicacion.

# ejecutando el emulador
cd android-sdk-linux_x86/tools
./emulator -cpu-delay 0 -no-boot-anim -cache ./cache  -verbose -avd android_223

las opciones -cpu-delay 0 -no-boot-anim -cache ./cache, mejora un poco el rendimiento haciendo mas responsivo el emulador.

android on fedora 14 x86-64
android on fedora 14 x86-64

referencia:

Android Developers

Detección y redirección de móviles con Apache mod_rewrite.

Cuando se desarrollan aplicaciones web o versiones móviles de sitios una aspecto fundamental es la detección del móvil y sus capacidades existen 2 opciones para realizar esta tarea ambas utilizan base de datos formatos XML con las características de los móviles una es opensource WURFL y la otra es Device Atlas la cual funciona en base a licencias, gratuita para evaluación con la data de ambas es posible implementar la detección del móvil y sus capacidades.

Ahora bien como dice el titulo de este articulo detección y redirección con Apache mod_rewrite , si no se requiere una solucion compleja lo mas sencillo y rápido si se esta trabajando con Apache es usar su modulo de re-escritura de url ( mod-rewrite ) y eso es mediante unas cuantas reglas en un archivo .htaccess en el directorio como estas:

RewriteEngine On

RewriteCond %{HTTP_USER_AGENT} ^(Android|BlackBerry) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^(Motorolla|Nokia|Samsung|SonyEricsson) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} iP(hone|od) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} .*Mobile.*Safari

RewriteRule ^$ http://movil.midominio.com  [R=301,L]

La deteccion es proporcionada por las expresiones regulares evaluadas de la variable “HTTP_USER_AGENT” y la redireccion por la expresion “RewriteRule ^$ http://movil.midominio.com [R=301,L]” en este caso por ejemplo tenemos un sitio en “midominio.com” y una version movil en “movil.midominio.com” el htaccess redireccionara cada peticion que sea movil al subdominio automaticamente.