C# RabbitMQClient: Productor de mensajes básico (con WSO2) usando .NET/C# en VS2012

RabbitMQ es un broker de mensajería (ver entrada RabbitMQ primeros pasos con colas de mensajería). Vamos a tratar de usar el cliente para .NET en  un proyecto con MS Visual Studio 2012 para conectar a un broker de mensajería WSO2 (ver WSO2: Broker de mensajería IoT (WSO2 IoTS))

Para instalar el paquete RabbitMQ.Client en VS2012  es recomendable usar el gestor de paquetes incorporado NuGet (RabbitMQ.Client 4.1.3) ejecutando el siguiente comando:

PM> Install-Package RabbitMQ.Client -Version 4.1.3

Para instalar el paquete previamente hemos creado un nuevo proyecto C# para consola.

Importamos la librería con la línea


using RabbitMQ.Client;

La clase ConnectionFactory construye instancias de IConnection y permite configurar el nombre el host, el virtual host y las credenciales de acceso. En vez usar las propiedades  factory.UserName, factory.Password… Compactamos la cadena de conexión en una sola línea usando la propiedad URI.


ConnectionFactory factory = new ConnectionFactory();
factory.Uri = "amqp://admin:admin@localhost:5672/carbon";

WSO2 usa el puerto TCP 5672 como broker de mensajería con el protocolo AMQP, podemos cambiar en cualquier momento el puerto editando el fichero C:\wso2mb-3.1.0\repository\conf\broker.xml.


El último parámetro del URI es el VHost, en WSO2 podemos encontrar información del VHost en C:\wso2mb-3.1.0\repository\conf\advanced\qpid-virtualhosts.xml. El VHost por defecto se llama “carbon”. Dentro del fichero también encontramos información sobre el exchange y queue (“amq.direct" is the default exchange that should be used for queue creation.).


IConnection conn = factory.CreateConnection();

IModel channel = conn.CreateModel();
channel.ExchangeDeclare("amq.direct","direct",true);

Le pasamos la conexión a la instancia IConnection empleado para crear nuevos canales.  La llamada a CreateConnection produce una excepción si el servidor WSO2 está parado por ejemplo.

El interface IModel se usa para el modelo AMQP le pasamos tres parámetros al método ExchangeDeclare. 

  • exchangeName: Un productor nunca envía directamente los mensajes directamente a la cola, en su lugar los envía a un exchange.

 

  • type: Debe ser uno de los siguientes “direct” (los mensajes van sólo a la cola especificada en routingKey), “topic”, “headers” o “fanout” (broadcast a todas las colas).
  • El tercer parámetro “durable” a true mantiene la cola persistente en el servidor.

La última parte es publicar el mensaje usando el método BasicPublish.

 var message = GetMessage(args);
 var body = Encoding.UTF8.GetBytes(message);
 
 channel.BasicPublish(exchange: "amq.direct",
 routingKey: "test-queue",
 basicProperties: null,
 body: body);

 channel.Close();
 conn.Close();

Código completo

Crear la cola en “test-queue” en WSO2

En el servidor WSO2 creamos una cola llamada “test-queue” a media que ejecutemos nuestro cliente publicador irá aumentando el contador de mensajes.

 

Referencias

WSO2: Broker de mensajería IoT (WSO2 IoTS)

WSO2 es un servidor de mensajería para conectar dispositivos IoT (ver entrada RabbitMQ primeros pasos con colas de mensajería), funciona como muchos otros servidores sobre un motor JDK (JMS – Java Message Service) lo que lo convierte en una solución multiplataforma de facto.  Permite trabajar con la base de datos embebida con la aplicación, para entornos empresariales puede trabajar con los sistemas de gestión de bases de datos más populares como Oracle, MySQL, PostreSQL.

Sin entrar en detalles un broker funciona como un enrutador de mensajería, las aplicaciones que se comunican con el servidor de mensajería pueden jugar varios roles, como productor / publicador de mensajes en un topic (gestión de colas basadas en contenidos) determinado o como consumidores / subcriptores de mensajes (Publish–subscribe pattern). El nodo central puede recibir de múltiples origenes y enrutar el mensaje al canal correcto, incluso transformar el mensaje a una representación alternativa.

WSO2: Working with Topics

Es arquitectura favorece la escalabilidad y la incorporación de nuevos nodos. La dependencia mutua entre aplicaciones se minimiza (decoupling), los publicadores que envían mensajes no lo hacen directamente a un receptor especifico, no tienen porque saber si al otro lado hay una aplicación, varias o ninguna recibiendo esos mensajes.

Podemos descargar el servidor del siguiente enlace. En la Web de descarga también ofrecen la subscripción a la comunidad y hospedar nuestra infraestructura IoT en su nube (Beta y previo pago).

Protocolos soportados:

  • Advanced Message Queuing Protocol (AMQP)(0-91))
  • Message Queuing Telemetry Transport Protocol (MQTT) v 3.1.1.

WSO2 IoTS es Open Source. He descargado el servidor wso2mb-3.1.0.zip a mi PC con Win7Pro y lo he descomprimido desde el raíz C:\wso2mb-3.1.0\.

Estructura de carpetas principales:

  • README.txt: El primer fichero que hay leer siempre.
  • bin: Script para Shell Linux y DOS.
  • client-lib: librerías JMS.
  • dbscripts: Scripts SQL para MySQL, Oracle…
  • lib: Librerías necesarias para WSO2.
  • repository.
    • conf: Ficheros de configuración.
    • database.
    • logs: Ficheros de logs de la ejecución.
  • resources: Recursos adicionales.
  • tmp: Ficheros temporales.

Una vez descomprimido sólo debemos ejecutar el script \bin\wso2server.bat para arrancar el servidor.

Una vez que arranca podemos administrar el servidor usando la aplicación Web en la siguiente dirección: https://localhost:9443/carbon  (usuario “admin” y clave “admin” por defecto).

Referencias externas:

 

 

 

 

 

Protocolos M2M en la nueva era de la IoT

internet-of-things-graphic-story-top

Protocolos M2M en la nueva era de la IoT

Me parece que me ha quedado un título de post algo presuntuoso, el objeto del texto que sigue es recopilar algunos protocolos que se están imponiendo y por ende estandarizándose en las comunicaciones M2M (Machine To Machine).

Internet de las cosas (IoT por sus siglas en ingles Internet of Things) es un termino acuñado recientemente y que está de moda en textos técnicos en Internet, básicamente se refiere a la interconexión digital de objetos cotidianos a Internet, con la proliferación de pequeños dispositivos de captación de datos instalados en cualquier objeto cotidiano estos pueden ser controlados y los datos producidos explotados de manera “inteligente” en la nube (flotas de vehiculos, ). Iot también se refiere al momento en que los dispositivos conectados a la red de redes sean mayor en número que las propias personas. Todos estos dispositivos conectados a Internet de manera heterogénea a su vez producen datos de forma masiva a gran escala, la necesidad de almacenar y explotar estos datos de manera no convencional nos conduce a otro termino denominado Big Data, pero imagino que esto ya es otro tema.

Buceando por Internet me he topado con más información de la que esperaba y que se puede encontrar en los enlaces al final del post, imagino que el reto consiste en un protocolo multiplataforma y ligero que se pueda implementar en cualquier plataforma. Estas comunicaciones deben poder implementarse para luchar contra algunas barreras inherentes a estos dispositivos como un limitado ancho de banda caidas casuales, otros problemas que podemos citar es su limitada capacidad de procesamiento y la necesidad de minimizar su consumo de energia.

Como resultante de todas estas propiedades estos dispositvos requieren características propias en la comunicación M2M, al calor de este nuevo mercado emergente sugen uniones de empresas y grupos que quieren liderar el desarrollo de un estandar como el grupo formado por Sierra Wireless, la fundación Eclipse y IBM entre otros (M2M Magazine “Sierra Wireless, IBM, Eurotech create M2M Group“). Otros grupos industriales como la Open Mobile Alliance (OMA) también estan trabajando duro en esta dirección.

+INFO:

PROTOCOLOS

HTTP y REST

Hypertext Transfer Protocol (HTTP) es la vida de la Web, se usa cada vez que transferimos un documento o consultamos una página. REST es una forma simple para organizar la interacción entre sistemas independientes. se emplea por ejemplo en la API de Twitter, gracias a que los datos necesarios para transferir datos mediante este sistema no consume excesivo ancho de banda. REST está inspirado por el protocolo HTTP y en la practica significa que podemos usarlo donde usemos un protocolo en HTTP como un servidor Web.

Otras alternativas como SOAP son algo más complejos y estan basados en lenguaje XML, requieren un estudio conciencudo de su sintaxis.

En el protocolo HTTP las maquinas juegan dos roles diferentes: Cliente y servidor. En la mayoria de los casos el cliente inicia la comunicación y el servidor responde. HTTP está basado en carácteres de texto aunque el cuerpo del mensaje puede contener otro tipo de datos como una imagen. Un mensaje HTTP está formado por una cabecera y un cuerpo a pesar de que el cuerpo a menudo puede ir vacio, el cuerpo contiene los datos interpretados como indica la cabecera.

Con Chrome Developer Tools, o Firefox con Firebug podemos espiar las peticiones HTTP en acción.

 CapturaOtro herramienta para familiarizarse con el protocolo HTTP es cURL.

cURL es una herramienta para usar en un intérprete de comandos para transferir archivos con sintaxis URL, soporta FTP,FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, FILE y LDAP.

[…]

Es por ejemplo una buena herramienta para simular las acciones de un usuario en un navegador web. Libcurl es la biblioteca/API correspondiente que los usuarios pueden incorporar en sus programas;

Para realizar pruebas con cURL nos montaremos nuestro propio servidor Web, con XAMPP  (Apache + MySQL + PHP + Perl) tenemos una distribución de Apache instalada en un periquete.

cURL suele estar disponible por defecto en muchas distribuciones Linux, en cuanto a Micro$oft esto ya es otro cantar, seleccionamos de la página oficial de descargas en http://curl.haxx.se/download.html (la versión 7.3.9 para Win32 que finalmente bajamos de aquí).

Una vez instalado cURL realizamos nuestra primera prueba, el comando:

curl.exe -v google.com

Nos muestra el dialogo HTTP que mantiene cURL para obtener la página solicitada (peticiones precedidas con “>” y respuestas con “>”).

Captura

Sintaxis

Una URL nos permite identificar el objeto sobre el que vamos a operar, cada URL identifica un recurso, vamos a verlo más claro, supongamos que queremos obtener una lista de clientes de nuestra compañía, el recurso podría ser:

/clients

Si quisiéramos buscar un cliente concreto:

/clients/jim

Asumiendo que sólo hay un cliente con ese nombre. Si lo completamos la llamada quedaría como queda:

GET /clients/jim HTTP/1.1
Host: example.com

Es un error muy común y que debemos evitar es usar la URL para describir la acción por ejemplo: /clients/add.

¿Pero como especificamos una acción? Los métodos HTTP vienen a nuestro rescate para este menester.

Más arriba hemos usado el método GET pero podemos usar otros métodos por ejemplo para borrar un cliente llamado “anne” de nuestra base de datos:

DELETE /clients/anne HTTP/1.1

Los métodos HTTP indican que operación realizar con el recurso solicitado en la URL. La petición puede tener información extra en el cuerpo del mensaje (en cURL podemos proporcionar estos datos usando la opción -d).

Los métodos más importantes son los siguientes: GET, POST, PUT y DELETE (podemos encontrar todas las opciones en IETF).

+INFO:

Cliente HTTP GET en C con WinInet (MS VS 2008)

#include "stdafx.h"
#include<windows.h>
#include<wininet.h>
#include<stdio.h>
#pragma comment(lib, "wininet.lib")

int _tmain(int argc, _TCHAR* argv[])
{
 HINTERNET Initialize,Connection,File = NULL;
 DWORD dwBytes;
 char ch;

 Initialize = InternetOpen(L"Mozilla/4.0 (compatible)", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
 if (Initialize == NULL)
 {
      printf("Error InternetOpen rets %s\n", "null");
 }

Connection = InternetConnect(Initialize, L"127.0.0.1",  INTERNET_DEFAULT_HTTP_PORT,  NULL,  NULL,  INTERNET_SERVICE_HTTP, 0,  0);
 if (Initialize == NULL)
 {
     printf("Error InternetConnect rets %s\n", "null");
 }

 File = HttpOpenRequest(Connection,NULL,L"/index.php?var1=val1&var2=val2",NULL,NULL,NULL,0,0);
 if (File == NULL)
 {
 printf("Error HttpOpenRequest rets %s\n", "null");
 }

 if(HttpSendRequest(File,NULL,0,NULL,0))
 {
 while(InternetReadFile(File,&ch,1,&dwBytes))
 {
 if(dwBytes != 1)break;
 putchar(ch);
 }
 }
 else
 {
 printf("Error HttpSendRequest rets %s\n", "null");
 }
 InternetCloseHandle(File);
 InternetCloseHandle(Connection);
 InternetCloseHandle(Initialize);
 return 0;
}

Servidor PHP


<html>
<head>
<title>Ejemplo de PHP</title>
</head>
<body>
<H1>Ejemplo de procesado</H1>
<?php var_dump($_GET) ?>
<br>
</body>
</html>

Resultado ejecución aplicación WinInet

Captura

+INFO:

Raspberry PI: Primeros pasos

Ingredientes:

811117175_85117_251584147153583061 811117867_84417_16410240432806148108

 

 

PASO 1: Bajar y grabar la imagen del sistema operativo

Captura

La imagen se puede descargar de http://www.raspberrypi.org/downloads/, yo he elegido “NOOBS Offline and network install” versión 1.3.10, bueno en realidad he hecho trampa y me he instalado RASPBMC que convierte tu Raspberry en un centro multimedia 😉 ).

 

Para grabar la imagen es necesario un programa que pueda grabarla en la Micro SD:  Win32 Disk Imager parece que cumple con lo que necesitamos sin ser excesivamente complejo de usar.

La imagen está comprimida pero podemos descomprimirla con 7Zip.

Captura

Bueno primera prueba superada, tan fácil como conectarle un pendrive con una pelis y funcionando!

811117541_84508_17296193211805409791

Otra herramienta necesaria para formatear la tarjeta SD (en FAT) es SD Formatter 4.0 for Windowshttps://www.sdcard.org/downloads/formatter_4/eula_windows/

Captura

 

Ahora nos ponemos un poco más serios e instalamos Raspbian. Usando SD Formatter formateamos la tarjeta SD en nuestro ordenador y a continuación copiamos los contenidos de la carpeta con la imagen descomprimida:

Raspbian es una distribución basada en Debian optimizada para el hardware de Raspberry Pi, a pesar de que la mayoría de usuarios domésticos usan distribuciones más populares como Ubuntu o Fedora, Debian es una de las distribuciones de Linux más respetadas (especialmente por los amantes del software libre).

  • Username: pi
  • Password: raspberry

Paso 2: Entorno para desarrollo aplicaciones C

Normalmente cuando desarrollamos aplicaciones para dispositivos embebidos el entorno de desarrollo es el PC de escritorio o portátil que usamos a diario en nuestro trabajo. Normalmente esto implica que necesitamos un compilador cruzado,  necesitamos compilar la aplicación en nuestro ordenador pero que sea ejecutable en el hardware de la Rasperry Pi (que no tiene nada que ver con el hardware de nuestro ordenador).

Otra alternativa que parece factible mientras buceo por la red es virtualizar el sistema operativo en nuestro ordenador con QEmu o Virtual Box. Creo que optare por esta segunda opción que parece más sencilla y ademas ofrece más posibilidades a la larga tener el mismo sistema operativo virtualizado en nuestro ordenador para realizar pruebas.

Parece que es QEmu (volvemos a encontrarnos viejo amigo) la aplicación que debemos usar ya que al contrario que Virtual Box con QEmu podemos virtualizar sistemas operativos que corren sobre una arquitectura diferente de la nuestro PC, normalmente x86 cuando RPi es ARM.

Podemos encontrar todo lo necesario para emular RPi en Win en SourceForge “Raspberry Pi emulation for Windows  Simple Raspberry Pi qemu emulation in Windows for beginners: http://sourceforge.net/projects/rpiqemuwindows/

Una vez descargado y descomprimido qemu.zip de 505 MB ejecutamos el script run.bat.

Captura

Captura

 

Captura

Lo primero que he echo es habilitar el servidor SSH para poder conectarme a la máquina virtual.

A continuación seleccionamos finalizar y entramos en la línea de comandos (usar instrucción startx para arrancar el sistema gráfico).

No he podido resistir la tentación y escribo mi primer comando para comprobar si el compilador gcc está presente ¡Lo está!

Captura

También incorpora mi querido editor de consola Vi.

Mi primer programa para RPi “Hello World!”

pi@raspberrypi ~ $ vim helloworld.c
pi@raspberrypi ~ $ cat helloworld.c
#include <stdio.h>
void main()
{
 printf("Hello World!\n");
}
pi@raspberrypi ~ $ gcc -Wall helloworld.c -o helloworld
helloworld.c:2:6: warning: return type of âmainâ is not âintâ [-Wmain]
pi@raspberrypi ~ $

Paso 3: Conectar nuestra RPi a la red

He conectado la RPi al router de casa usando un cable de red normal, para asignarle una dirección IP usando DHCP.

pi@raspberrypi ~ $ sudo dhclient eth0

Ya tengo una IP asignada (192.168.1.11).

También compruebo que desde el resto de equipos de cada puedo hacer ping a RPi.

Una vez en la misma red puedo conectarme por SSH y trabajar desde mi portátil.

 

Paso 4: Instalar paquetes

pi@raspberrypi ~ $ sudo apt-get install vim


Futuro: Usar GPIO para leer E/S

GPIO es un pin genérico de E/S.

Raspberry-Pi-GPIO-pinouts

53bc258dc6c0425cb44870b50ab30621

 

+INFO: