viernes, mayo 23, 2008

Diseño de redes inalámbricas con Radio Mobile (I)

¡Buenas de nuevo!

Como lo prometido es deuda, y después de las entradas "facilonas" en las que sólo colgaba 2 libros para su descarga (que son muy buenos, de veras); ahora me voy a mojar un poquillo más y en esta entrada me he propuesto diseñar una red con Radio Mobile. Para demostrar su aplicación, vamos a hacer como ejemplo una red ya existente que se diseñó con este software, y que viene a ser la red que la Fundación EHAS instaló en marzo del año pasado a lo largo del río Napo, en los distritos de Napo y Torres Causana, provincia de Maynas, región de Loreto, en el Perú amazónico. Se trata de una red orientada a salud que se pretende (y de hecho lo está haciendo desde ya hace un año) que de los servicios de telefonía, correo electrónico, internet y diversos de telemedicina (en esto último la red aún no está lo suficientemente explotada y se está trabajando en buscar soluciones de telemedicina útiles y aplicables en estos entornos) para los centros de salud de una región aislada del planeta. Los beneficiarios directos del proyecto serán por tanto los centros de salud, que si tuviéramos delante el árbol de soluciones de El Marco Lógico de nuestro proyecto, nos daríamos cuenta de que repercuten directamente en la mejora de las condiciones de la población local.

Para situarnos un poco más, os pongo el mapa de direccionamiento de la red del que nosotros nos encargaríamos de diseñar todos los enlaces inalámbricos.

Llegado este punto, alguno pensará "...y si se trata de enlaces inalámbricos WiFi, ¿para qué #$%/& hay que usar un software de diseño? yo en mi casa pongo mi router a funcionar y a ¡ale! ¡a correr!". Pues bien, eso está genial para enlaces cortos típicos de redes locales WiFi, que no superan los 300m en el mejor de los casos, pero los enlaces que vemos en el mapa que arriba pongo, llegan a tener hasta 42km entre nodos, en una región tropical selvática con la atenuación de señal que humedad, selva y demás asuntos introducen en nuestros balances de enlace, y todo ello sin dejar de ser WiFi (aunque como ya veremos en futuras entradas, para el correcto funcionamiento de estos enlaces hace falta hacer algunos truquillos con el driver Madwifi para tarjetas con chipsets atheros sobre linux que rompen ligeramente el estándar WiFi sin abandonar la interoperabilidad con cualquier otro dispositivo que cumpla el estándar 802.11).

Por otras entradas del blog, muchos/as ya sabréis que soy un linuxero empedernido, así que usar software diseñado para windows habitualmente me produce urticaria, pero dado el buen uso que puede tener este software y para que me duela menos, explicaré el proceso sobre una "Ubuntu 8.04", la última versión disponible, instalando una máquina virtual "VirtualBox" sobre la que se instalará a su vez un Windows XP. Si me da el venazo, igual os explico también cómo hacerlo directamente sobre Linux usando el emulador "Wine".

Lo primero que vamos a hacer es descargarnos la máquina virtual "VirtualBox" y para ello nos vamos a su página web y nos descargamos el software (decir que Sun Microsystems anunció en febrero de este año la adquisición de la empresa responsable de VirtualBox, que es Innotek GmbH, por lo que el software ha pasado de llamarse "Innotek VirtualBox" a ser ahora "Sun xVM VirtualBox 1.6", ya sabéis, chorradas empresariales de nomenclatura. Los que tengáis la antigua máquina virtual, os vale lo mismo, pero probablemente la página sea alojada dentro de poco en los servidores de Sun). Para la descarga seleccionamos nuestra plataforma (Ubuntu 8.04 x86), marcamos el tradicional cuadro de aceptar licencia "I agree" (cualquier día me da el venazo y me leo una de estas licencias pa saber lo que estoy aceptando :) ) y pinchamos en el botón "Continue". La cosa no podía ser más sencillica. Nos sale un paquete .deb para descargar. Lo descargamos corriendo antes de que nadie nos lo quite :D. Para instalarlo, nos bastará un "sudo dpkg -i nombre_paquete.deb" en un terminal.

Pero para quien eso de abrir una consola le de urticaria, siempre está la opción de nuestro amigo el synaptics (gestor de paquetes). Se abre, se busca por virtualbox, se marca el paquete para su instalación y luego se pulsa en "Aplicar". No tiene pérdida.




Después de la instalación de VirtualBox, ya lo tenemos en Aplicaciones -> Herramientas del sistema -> VirtualBox OSE. Pues bien, pulsamos en él para abrirlo. Como se podía intuir, nuestra intención será crear una nueva máquina virtual, así que pinchamos en el botón de "Nueva" y comenzamos a configurarla.






Lo primero es un típico "Siguiente". Luego damos un nombre a nuestra máquina y seleccionamos el tipo de sistema operativo que instalaremos en ella (en nuestro caso un Windows XP...¡uy! ¡qué dolor ver esas letras juntas!). Como parece que le he pillado el gustillo a esto del botón "impr pant" del teclado.

Pulsamos en "Siguiente" y nos preguntará la memoria base que queremos destinar a la máquina virtual. La mínima son 192MB, pero para darle más soltura a la cosa, yo le he puesto 512MB, dependerá de cuánta tengáis. Si le ponéis muy poca irá más lento, pero por contra no os comerá terreno a vuestro preciado GNU/Linux. Pulsamos en "Siguiente", y ahora nos toca crear un disco duro para nuestra máquina virtual. Bueno, aquí tenemos la opción de que el disco duro tenga un tamaño estático o un tamaño dinámico (que crecerá cuando se vaya agotando). Ésto se traducirá en un fichero .vdi, que luego podremos borrar o copiar a nuestro antojo para trasladar nuestra máquina virtual a otro sitio. Yo he decidido usarlo de 10GB iniciales y dinámico...
Ya sabéis..."Siguiente" y "Finalizar" cuando os lo pida.

De vuelta al proceso de creación de la máquina, ahora seleccionamos el disco duro que acabamos de crear como primario de nuestra nueva máquina y pinchamos en "Terminar". Y ahí está, ya tenemos a nuestra pequeña creada, a la espera de ser configurada y luego instalada.

Hagamos antes de la instalación algunos retoques de configuración, son poquitos. Con la máquina seleccionada, pinchamos en el botón de "Configuración". Primero, si disponemos de suficiente memoria de vídeo, le daremos un poco más de holgura a la máquina, para que nuestro Radio Mobile se mueva agusto.

Ahora es buen momento para introducir en vuestra lectora de CD o DVD el disco de instalación de un Windows XP (no seré yo quien os diga si el disco ha de ser original o pirata :) ). Nos vamos a la sección de "CD/DVD-ROM" y marcamos la casilla de "Monta la unidad de CD/DVD".

Lo siguiente será activar el audio. Nos vamos a la sección "Audio" y marcamos "Habilitar Audio". Finalmente pincharemos en "Ok" y ya está, ya estamos listos para instalar un sistema operativo peor que el anfitrión, pero que nos dará la posibilidad de diseñar nuestra red inalámbrica mediante el software de Radio Mobile. Para arrancar la máquina, ahora ya sí, pinchamos en el botón "Iniciar" con nuestra máquina seleccionada.

Al darle a "Iniciar", nos sale un cuadrito que nos familiariza con el funcionamiento de VirtualBox. Se nos recuerda que cuando pulsemos sobre la ventana de la máquina virtual (mientras no esté instalado algo que haremos más tarde), la máquina huésped (Windows) se hará con el control de nuestro teclado hasta que pulsemos la "Tecla anfitrión", que viene a ser por defecto el CTRL DRCHO. Cuando pulsemos esa tecla, nuestro teclado y ratón actuarán sobre nuestro sistema anfitrión (GNU/Linux Ubuntu).



...y hecho ésto...

¡¡ALARM, ALARM!!

La maquinilla nos chilla que nanai, pero afortunadamente el mensaje de error contiene la solución del problema así que no tendréis mucho problema en solucionarlo. Sólo tenemos que instalar el paquete que nos pide. Lo hacemos con "sudo aptitude install virtualbox-ose-modules-2.6.24-16-generic" en un terminal. Lo siguiente será introducir a nuestro usuario dentro del grupo "vboxusers", y para ello nos vamos a "Sistema -> Administración -> Usuarios y Grupos". Ahí pinchamos en "Gestionar Grupos", luego seleccionamos el grupo vboxusers y marcamos nuestro usuario para que se agregue al grupo. Cerramos y ya lo tenemos, pero para que el usuario sea efectivamente agregado, tendremos que reiniciar. Para quien prefiera hacer las cosas desde un terminal, se puede agregar un usuario al grupo vboxusers sólo escribiendo "sudo adduser vboxusers" (mucho más rápido, ¿eh?).






Luego pulsamos en "Iniciar" y como tenemos introducido el cd de instalación de Windows, el resto podemos decir que ya es historia, la vieja historia de la instalación de un Windows y que resumiré en capturas:








Y ... ¡voilà! Ya tenemos el windows sobre el que instalaremos nuestro Radio Mobile, pero la instalación del software os la contaré en la siguiente entrada. Ni que decir tiene que lo que tenemos ya instalado es un windows plenamente funcional, así que se le puede instalar cualquier cosa que se pudiera instalar sobre un sistema no virtualizado (aunque parece ser que algunas cosas como la aceleración gráfica aún no está muy conseguida).

¡Hasta la próxima entrada!

sábado, mayo 17, 2008

Libro "Redes Inalámbricas en los Países en Desarrollo"


Buenas a todos de nuevo, aquí os dejo otro libro más sobre redes inalámbricas, éste un poco más antiguo, surge del proyecto WNDW (Wireless Networking in the Developing World) y os puede ayudar a informaros más a fondo sobre estos temas. Espero que os sea de utilidad. Lo podéis descargar igual que el anterior porque también está licenciado bajo Creative Commons. Si preferís descargaros la segunda edición en inglés, también la tenéis aquí disponible.

lunes, mayo 12, 2008

Libro "Redes Inalámbricas para Zonas Rurales"


El Grupo de Telecomunicaciones Rurales de la PUCP (Universidad que es contraparte local de los proyectos que la Fundación EHAS desarrolla en Perú, como el que os relataba en el blog "Cooperante no hay camino..."), ha publicado un libro que trata en profundidad el despliegue de redes inalámbricas para zonas rurales de países en desarrollo. Podéis descargar el libro si lo deseáis ya que está licenciado bajo Creative Commons. Os lo recomiendo, hay mucho conocimiento ahí condensado.

viernes, marzo 28, 2008

Motor de informes dinámicos con iTextSharp (I)

Actualización: he colgado los códigos del proyecto para que podáis jugar con ellos y utilizarlos en vuestros proyectos. Los podéis descargar desde aquí

Buenas de nuevo a todo el mundo que lee este blog (cada día sois más, lo que es de agradecer). He estado muy ocupado últimamente montando mi propio motor de informes dinámicos utilizando la librería iTextSharp para generación de documentos PDF.

La idea inicial era poder disponer (dentro de una aplicación ASP.NET) de un sistema de impresión de informes con tres características principales:
  1. Impresión de informes al vuelo en PDF
  2. Disponer de plantillas en XML para mezclar datos de base de datos y mostrarlos en PDF (también al vuelo).
  3. Poder modificar las plantillas XML desde un editor
Con estos requisitos me puse manos a la obra con iText# (una librería excelente) y os explico cómo lo plantee por si os sirve para vuestros desarrollos o como punto de partida para otras cosas.

Impresión de Informes al vuelo en PDF
Ésta fue la parte más fácil y más complicada a la vez. La más complicada porque me pegué de lleno con la librería y la más fácil cuando aprendí los entresijos de la misma. Para imprimir informes en PDF al vuelo basta con seguir el siguiente ciclo:

















La idea consiste en generar los datos a imprimir en la pagina aspx donde esté el usuario. Esos datos los guardamos en la sesión y llamamos a la pantalla MostrarInforme.aspx. Esta pantalla recupera los datos de la sesión y se los pasa a la clase GeneradorPDF.cs que se encarga de crear el PDF (en memoria) en base a los datos pasados. El método que genera el PDF devuelve un objeto del tipo MemoryStream a la página MostrarInforme.aspx, el cual es renderizado en pantalla mediante un Response.OutputStream.Write().

Dicho así, la verdad es que no aclaro demasiado el tema, así que vamos a ver el código que siempre ayuda más.

El Código
Lo primero fue plantearme el alcance de esta parte del motor de informes. Lo que queríamos era poder imprimir cualquier tabla de cualquier pantalla con cualquier tipo de campos y número de una forma común y fácil. Con este objetivo en mente, lo inicial fue definir las variables de sesión en las que se iban a pasar los datos desde las páginas a la pantalla MostrarInforme.aspx:
  • DataTable con los datos
  • DataTable con los nombres de las columnas de la tabla que se quieren imprimir y el nombre que se le pone a cada una de ellas en el informe.
  • Orientación de la página para poder imprimir en apaisado y en vertical
  • Anchos (en porcentaje) de las columnas que se van a imprimir
  • Nombre del listado que aparecerá en la cabecera
1. Preparar la Impresión
Con estas variables de sesión tenemos información suficiente para poder imprimir el informe. Un ejemplo de cómo se preparan las variables de sesión en una pantalla es el siguiente:

















En este método lo que hago es crear las variables de sesión necesarias (casi todo está con enumerados y struct).
  1. TABLA_DATOS: Para el Datatable con todos los datos.
  2. ORIENTACION_PAGINA: para decirle si queremos imprimir en vertical o en horizontal.
  3. CAMPOS_A_IMPRIMIR: para indicar aquellas columnas del datatable de datos que queremos imprimir y el nombre que queremos que aparezca en la cabecera de dicha columna en el informe. Aquí utilizo un datatable tipado DtCamposListadoPDF.
  4. ANCHOS_DE_COLUMNA: array de enteros con los anchos de cada una de las columnas (en el mismo orden) que he introducido en CAMPOS_A_IMPRIMIR.
  5. TITULO_LISTADO: Título que va a llevar el informe.
2. Llamar a MostrarInforme.aspx
Una vez que tenemos las variables de sesión, llamaremos a la pantalla MostrarInforme.aspx desde nuestra aplicación. Para abrirla hay varias opciones (Javascript, inyectando código). A mi lo que me interesaba era que se mostrará el PDF en una nueva ventana, así que llamo a la página desde Javascript, con un window.open.

También se puede hacer con:



El código de MostrarInforme.aspx es el siguiente:













Todo se realiza en el Page_Load() porque vamos a devolver un Stream al navegador. Lo primero que hacemos es recuperar las variables de sesion que la página ha creado. Obtengo también la ruta de una imagen que va a aparecer en plan logo en los informes para pasarla al método.
Una vez obtenidos los datos llamo al método estático GenerarListado que va a devolver un MemoryStream con el PDF.

Con el MemoryStream lo que hago es renderizarlo en la pantalla mediante el objeto Response. Vamos a ver cómo genero el PDF al vuelo.

3. Generar el PDF
El método GenerarListado de la clase GeneradorPDF es el que realmente se encarga de crear dinámicamente el informe PDF.

Los using que tenemos que utilizar son:







En la primera parte del método definimos el objeto Document que va a contener el PDF, la orientación y enlazamos el objeto MemoryStream con el objeto Document para indicarle que vamos a realizar las operaciones en memoria.




















En segundo lugar llamamos al método IncluirElementosComunes para crear la cabecera del informe, el título y para que incluya el logo:




El código de este método es el siguiente:




















En este método creamos la cabecera del informe, una tabla con el logo en una celda y con el título del listado y la fecha de impresión en la otra. Además, en este método abrimos la escritura en el documento con la instrucción docPdf.Open().

Volviendo al método general, las siguientes instrucciones lo que van a hacer es ir creando una tabla, con tantas columnas como le hemos pasado en sesión y la vamos rellenando con los datos del Datatable de datos.






















Vamos iterando sobre los datatables e incluyendo la información. En esta parte, cada uno dará al informe el aspecto que más le guste. Al final incluimos la tabla en el documento PDF.

Para finalizar lo que tenemos que hacer es capturar los errores, cerrar el PDF y devolver el stream.









Una muestra de un informe en PDF generado por esta función es el siguiente:























Final
En la próxima entrega veremos como realizar las plantillas XML con parámetros y cómo mezclarlas con datos de bases de datos de una forma dinámica. Finalmente, en la tercera entrega veremos como editar las plantillas y cómo crearnos traductores XML y HTML para dichas plantillas.

Espero que os haya interesado este primer artículo y que lo aprovechéis para vuestros desarrollos.

martes, marzo 04, 2008

Firmar una llamada SOAP con C# y ASP.NET

En este artículo voy a intentar explicar cómo firmar una llamada SOAP utilizando la extensión para servicios web WS 3.0 de Microsoft. Como siempre, lo primero es un poco de teoría y luego veremos cómo pasar esta teoría a la práctica.

Es recomendable que os leáis el artículo anterior a este sobre certificados digitales de la FNMT puesto que haremos uso de lo que en él comentaba.

1. Teoría
La idea es poder realizar una llamada a un servicio web externo (una administración, por ejemplo) asegurando que el contenido de la misma no ha sido manipulado en el camino. El ejemplo más claro es el de una aplicación web que se integra con la administración, por lo que tiene que firmar las peticiones con el certificado de la FNMT del cliente que en ese momento este usando la aplicación.








La idea es que nosotros seamos una especie de pasarela de certificados de nuestros clientes a los servicios web de la administración o de otro sitio. Para realizar esto tendremos que firmar las llamadas SOAP con el certificado usando el estándar XMLSignature.

2. ¿Cómo lo hacemos?
Para hacerlo, lo primero que tenemos que hacer es descargarnos las extensiones de Servicios Web de Microsoft (WSE 3.0) que podéis encontrar en la dirección:

http://www.microsoft.com/downloads/details.aspx?FamilyID=018a09fd-3a74-43c5-8ec1-8d789091255d&displaylang=en

Una vez instalado en nuestro equipo, tendremos una nueva opción en Visual Studio para el trabajo con las extensiones de Web Services.

¿Cómo funciona WSE 3.0?
El centro del tema este son las políticas y los filtros. Cuando realizamos una llamada a un servicio web, ésta es interceptada por una clase que define lo que hay que realizar con dicha llamada antes de que salga. Cuando recibimos una respuesta, la respuesta es interceptada igualmente, y lo mismo pasa cuando definimos los servicios web.




Donde nosotros vamos a trabajar es en la clase de políticas de seguridad, que será donde se firme la petición.

Paso 1: Habilitar nuestro web para WSE3.0
Lo primero es habilitar nuestro sitio web para que utilice WSE3.0. Al habilitarlo, las clases proxy que se creen estarán preparadas para las extensiones de WSE. Tendremos que crearnos un sitio web en el Visual Studio y en las propiedades del sitio web veremos cómo aparece una nueva opción "WSE Settings 3.0". Al pinchar se abre la ventana:
























Marcamos la primera opción para habilitar las opciones del cliente. La segunda opción es para habilitar las opciones cuando nosotros somos el servicio web.

Paso 2: Agregar la referencia a WSE
Agregar una referencia a la librería Microsoft.Web.Services3 a nuestro proyecto.

Paso 3: Agregar la referencia web
Agregaremos la referencia web al servicio con el que nos queramos comunicar.

Paso 4: Crear la política de seguridad
Vamos a crear la clase que controla la entrada y salida de mensajes SOAP desde el cliente. Esta clase tiene que heredar de
SecurityPolicyAssertion
















La clase tiene cuatro métodos, uno para cada situación: salida/entrada para el cliente y salida/entrada para el servicio. A nosotros el que nos interesa es el de la salida para el cliente, el resto lo ponemos a null.

La sección de imports es la siguiente:












En el constructor le pasamos el certificado del cliente (luego veremos cómo llamamos a esta clase) para poder utilizarlo en el método de salida del cliente. En este método lo que hacemos es instanciar una nueva clase que hereda de SendSecurityFilter que es la que realmente firma la petición:












En esta clase lo que hacemos es obtener el token del certificado y añadirle la firma al mensaje SOAP, haciendo override del método SecureMessage. Con esto tenemos prácticamente hecho todo.

Paso 5: Realizar la llamada
Nos creamos una página aspx desde la que vamos a realizar la llamada. Lo primero será obtener el certificado del cliente (ver el artículo anterior), una vez obtenido tendremos que asociar la política que hemos definido con la llamada al servicio web:
























En este caso, he creado un servicio web con un método llamado "CalculaSuma" el cual suma dos números que se le pasan. En un botón llamado "btnInvocar" de la página le asocio el código para llamar al servicio web. Lo que hacemos es instanciar la clase proxy que se creó al agregar la referencia web y le asociamos la política que hemos creado.

Al realizar la llamada, la política intercepta el mensaje de salida, ejecuta el método "SecureMessage()" y firma la petición. Podemos activar el modo Trace con el asistente de WSE y ver la salida para comprobar que se ha firmado la petición, incluyéndose un nuevo elemento en la llamada SOAP llamado
.

3. Fin
Espero que os haya gustado y servido este post. No ha sido muy exhaustivo pero como punto de partida para la utilización de XMLSignature en SOAP puede ser bueno.