Nos sirve para hacer operaciones de agregación sin necesidad de bajarnos todos los datos al cliente.

Lo que hacemos es definir funciones en JavaScript, una en la que definiremos los datos que queremos usar (map) y otra como queremos tratarlos (reduce), y le mandamos esas dos funciones al servidor definiéndole el flitro de datos y donde queremos que nos deje el resultado.

Lo mejor es verlo con un ejemplo, en este caso lo pondré en Ruby que es en lo que tenemos hecho nuestra aplicación de logs.

Nosotros estamos guardando en una colección de MongoDB datos desde el log de nuestro servidores web guardando servidor, fecha y hora de cuando recibimos la petición, el tiempo que ha tardado, etc. quitando los datos que no interesan al ejemplo, el documento es algo así:

 
{
  "_id" : ObjectId("4fa101ee78754332a4004cc6"),
  "datetime" : new Date("Wed, 02 May 2012 09:43:15 GMT +02:00"),
  "servername" : "SERVICESTMP2",
  "timetaken" : "436",
  "uri" : "/dingus/tazzy/hotelservice.asmx",
  "useragent" : "Mozilla/4.0+(compatible;+MSIE+6.0;+MS+Web+Services+Client+Protocol+2.0.50727.5448)",
  "status" : "200"
}

En nuestro caso esta colección se incrementa en varios millones de registros cada dia, así que sacar informes bajando todos los datos al cliente es una locura, aquí es donde es imprescindible el uso del MapReduce.

Por ejemplo, queremos saber cuantas peticiones estamos devolviendo cada hora por rango de tiempo en la respuesta.

Lo primero, definir la función map, en la que hacemos lo siguiente:

• Descomponemos la fecha para quitar los minutos y segundos para tener el Año Mes Dia Hora como unidad de agregación
• Definimos que valores serán clave en la agregación, en este caso el Año Mes Dia Hora y el nombre del servidor
• Definimos que valores serán los agregados, count, fijo a 1 para contar registros, y timetaken para agregar por rango de tiempo de respuesta:

map = "function Map() { 
	var day = new Date(this.datetime.getFullYear(), 
		this.datetime.getMonth(), 
		this.datetime.getDate(), 
		this.datetime.getHours()); 
	emit({day : day, servername: this.servername}, {count: 1, timetaken: this.timetaken}); 
		}"

Después definimos la función reduce, en la que hacemos lo siguiente:

• Definimos la estructura del resultado en result, el contador y las peticiones que tardan mas de 2, 5, 10 y 20 segundos
• Nos recorremos los registros y vamos asignado el resultado a result, incrementando el count e incrementado los countmore según el timetaken

reduce = "function Reduce(key, arr_values) { 
            var result = {count: 0, countmore2: 0, countmore5: 0, countmore10: 0, countmore20: 0};
 
            for(var i in arr_values) { 
            	result.count += arr_values[i].count;
 
	    	if(arr_values[i].timetaken > 20000) 
			result.countmore20 += arr_values[i].count; 
		else if(arr_values[i].timetaken > 10000) 
                        result.countmore10 += arr_values[i].count; 
                else if(arr_values[i].timetaken > 5000) 
                        result.countmore5 += arr_values[i].count; 
                else if(arr_values[i].timetaken > 2000) 
                        result.countmore2 += arr_values[i].count; 
            }
            return result; 
            }"

Con las dos funciones listas solo hay que mandárselas al servidores con el filtro de datos que nos interese y decirle donde queremos los resultados.

Puedes pedir los resultados en línea o que te los deje en una colección.

Las ventaja de tener los datos en una colección es que puedes hacer agregación sobre esa colección, ósea procesar este MapReduce cada hora y hacer reduce sobre los datos existentes en la colección, tambien puedes hacer un replace, un merge …

Con mongoid y haciendo reduce para agregar datos a la colección seria algo así:

• Hacemos el MapReduce y agregamos los resultados a la colección “requestbyday”
• Pedimos los datos de la colección.

WebLog.collection.map_reduce(map, reduce,
	{
        	:query =>  { :datetime => {'$gte' => datefilterfrom},
			     :datetime => {'$lte' => datefilterto}} ,
                :out => { reduce: "requestbyday"}
        })
 
@weblogs = WebLog.db.collection("requestbyday").find

las otras opciones de salida serian:

• replace: Si no exista la colección la crea y si existe elimina todos los datos y mete los nuevos
• merge: Si la key no existe la inserta, si existe la reemplaza por la nueva
• reduce: Lo que he explicado antes.
• inline: Devuelve los datos directamente, sin guardarlos en una colección.

Espero que sea de ayuda, cualquier comentario es bienvenido.

Si estas usando threads foregorund y tienes un WaitAny con timeout, quizás tu aplicación no se comporte como esperas …

El otro día estábamos trabajando sobre un servicio web de hub que recoge peticiones de un cliente crea varios mensajes para diferentes proveedores, se las envía junta las respuestas y se las devuelve al Cliente como una.

Teníamos el problema de que si algún proveedor estaba lento, que siempre hay alguno, ralentizaba todo el proceso, así que le pusimos un timeot al WaitAny para que, pasados un tiempo, dejara de esperar respuestas y continuara con el proceso, algo así:

for (int i = 0; i < Services.Count; i++)
{                
	XmlDocument DocOut = new XmlDocument();
	DocOut.LoadXml(rq.ToString());
	Services[i].myMethodAsync(DocOut);
}
 
WaitHandle.WaitAny(new[] { ev }, timeout);

Aunque el timeout estaba funcionando, ya que el servicio no incluía en la respuesta los que habían tardado mas que el timeout, el servicio no devolvía respuesta hasta que todos los servicios habían contestado …

Eso es debido a que los threads eran del tipo foreground y no dará por terminado el proceso hasta que todos terminen …

La solución, abortar los threads a mano después del timeout:

for (int i = 0; i < Services.Count; i++)
{                
	XmlDocument DocOut = new XmlDocument();
	DocOut.LoadXml(rq.ToString());
	Services[i].myMethodAsync(DocOut);
}
 
WaitHandle.WaitAny(new[] { ev }, timeout);
 
foreach (var service in Services)
{
	service.Abort();
}

De esta manera el proceso termina cuando tu quieres.

Es una buena practica, casi debería ser obligatorio, habilitar la compresión de las respuestas cuando haces peticiones a servicios web, el tiempo de uso de procesador es casi imperceptible y ganas mucho en tiempo de transmisión del mensaje, nosotros estamos pensando en lanzar una excepción cuando no nos lo pidan, mucha gente hace eso ya.

Para habilitar la compresión simplemente hay que mandar una cabecera http con Accept-Encoding: gzip.

Aquí dejo unos ejemplo de como habilitar la compresión.

En PHP con nusoap no tienes que preocuparte de nada, simplemente diciéndoselo al cliente el se encarga de mandar la cabecera y de descomprimir la respuesta:

$soapClient = new nusoap_client($wsdl,true); 
$soapClient->http_encoding = 'gzip'; 
$respuesta = $soapClient->call($metodo, $params);

En .NET, con proxys generados desde WSDL, lo mismo, simplemente hemos de activarlo en la propiedad EnableDecompresion:

Service service = new Service(); 
service.Url = url; 
service.EnableDecompression = true;

Si en .NET la petición la hacemos ‘a mano’ tenemos que encargarnos de meter la cabecera y descomprimir la respuesta, algo así:

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.Headers.Add("Accept-Encoding", "gzip");
WebResponse resp = reques.GetResponse();
Stream respStram = resp.GetResponseStream();
using (Stream streamGZip = new GZipStream(respStram, CompressionMode.Decompress))
{
    StreamReader reader = new StreamReader(streamGZip);
    string result = reader.ReadToEnd();                    
}

En Ruby quizás sea algo mas complicado ya que tienes que encargarte tu de descomprimir la respuesta, pero es sencillo, algo así:

req = Net::HTTP::Post.new(post_ws, initheader = {'Content-Type' =>'application/json', 'Action' => action, 'Format'=> 'json','Accept-Encoding' => 'gzip' })
req.body = rqjson
 
resp = Net::HTTP.new(host).start { |http| http.request(req) }
 
case resp
    when Net::HTTPSuccess then
      begin
       if resp.header[ 'Content-Encoding' ].eql?( 'gzip' ) then
        #debug.call( "Performing gzip decompression for response body" )
        sio = StringIO.new( resp.body )
        gz = Zlib::GzipReader.new( sio )
        page = gz.read()
        #debug.call( "Finished decompressing gzipped response body" )
       else
          #debug.call( "Page is not compressed. Using text response body" )
          page = resp.body
        end
       rescue Exception
        #debug.call( "Error occurred (#{$!.message})" )
        # handle errors
        raise $!.message
    end
end

Hace unas semanas empezamos a probar Bamboo como herramienta de integración continua para nuestros proyectos, queríamos probar el “On Demand” pero no tenia integración con git, así que lo tenemos instalado en un Windows 2008 R2.

Primero probamos con un proyecto sencillo, alojado en github sin dependencias y todo fue perfecto, se baja el código de Git, lo compila con MSBuild, pasa los test con NUnit y te envía un report, una maravilla …

Siguiente paso, subir uno de los proyectos de la empresa, algo mas complejo, con muchas referencias  (las referencias las tenemos en red y cada PC tiene una unidad mapeada a esa carpeta compartida, lo típico), pues no había manera de que Bamboo encontrara las referencias al compilar con MSBuild, lo raro era que, compilando con MSBuild en la línea de comandos del servidor, compilaba sin problemas …

El problema, el proceso que ejecuta el MSBuild no tiene esa unidad de red mapeada porque no ha iniciado sesión, la solución, añadir una tarea tipo Script antes de la tarea de compilación que nos monte la unidad de red.

En nuestro caso:

if not exist R:\nul NET USE R: \\127.0.0.1\References /USER:BUILDSERVER\user password /PERSISTENT:YES

Con esto el MSBuild siempre se encuentra la unidad mapeada y encuentra las referencias sin problemas.

MMS es un servicio gratuito que ofrece 10gen para monitorizar tus servidores de MongoDB.

Instalarlo es tan fácil como darte de alta en mms.10gen.com y bajarte e instalar en tu clúster el Agente MMS.

Una vez instalado empezaras a recibir todos los datos relevantes desde tu clúster, información de operaciones (escritura, lectura), uso de la memoria, del CPU, conexiones, uso de la red etc. ..

Además puedes configurar alertas por mail de caída de nodo, caída del Agente y que te avise si tu versión de MongoDB no esta actualizada.

Imprescindible si estas trabajando con MongoDB.

Hace un tiempo que venimos haciendo pruebas con esto a fin de eliminar SharedCache y MemCached y aprovechar la estructura de servidores de MongoDB en Replica Set que tenemos montada para almacenar los objetos.

Para almacenar los objetos en MongoDB hemos creado una librería, con los mismos métodos de que los clientes de Cache, que almacena los objetos en una colección con la key como _id y los datos en byte[] con la posibilidad de almacenarlos comprimidos.

Además hemos creado un visor de objetos en Windows Forms, los dos proyectos son Open Source y están en github.

https://github.com/emiliotorrens/MongoKeyValueClient.NET

Este es el resultado de unas pruebas en las que se hacen varios cálculos vía Servicio Web en dos instalaciones una tirando los objetos desde el servidor de Cache y otra tirando los objetos desde el Replica Set de MongoDB:

MongoDB, 10 Threads 120 segundos, 1 Servidor
Test Results:
Test Passed!
973 call(s) passed, out of 973
Average response time: 1.094 seconds

Cache, 10 Threads 120 segundos, 1 Servidor
Test Results:
Test Passed!
752 call(s) passed, out of 752
Average response time: 1.498 seconds

Las ventanas, para mi:

• Aprovechas tu estructura de MongoDB, si la tienes.
• Es fácilmente escalable, escalamos poniendo mas servidores en el Replica Set.
• Es fácilmente extensible, extendemos poniendo mas campos en la colección y añadiendo funcionalidad al cliente, tageando keys, relacionándolas etc.
• Es persistente.

Nosotros lo empezamos a poner en producción la semana que viene.

Acabo de subir una nueva versión de MongoMapper.NET a master que incluye una opción para generar el esquema desde al Assembly.

El método esta en ReflectionUtility y pasándole el Assembly donde tenemos definidas las clases que heredan de MongoMapper generara la colección y los índices que hayas definido con MongoKey y MongoIndex.

Es tan fácil como esto:

ReflectionUtility.BuildSchema(typeof(MyClase).Assembly);

 

Se puede usar con bases de datos ya creadas y colecciones con documentos ya que no borra nada solo añade, si has quitado un MongoIndex no lo  borrara, tendrás que ir y quitarlo a mano.

https://github.com/emiliotorrens/MongoMapper.NET

Primero vamos al ejemplo del archivo YAML

config/config.yml

development:
  perform_authentication: false
 
test:
  perform_authentication: false
 
production:
  perform_authentication: true
  username: admin
  password: secret

Ahora deberemos crear un inicializador para cuando arranque nuestra aplicación cargue la configuración donde APP_CONFIG es una variable a la que podremos acceder en rails

config/initializers/load_config.rb

APP_CONFIG = YAML::load_file("#{Rails.root}/config/config.yml")

Y por ultimo, el método donde accederemos al APP_CONFIG

application.rb

def authenticate
  if APP_CONFIG['perform_authentication']
    authenticate_or_request_with_http_basic do |username, password|
      username == APP_CONFIG['username'] && password == APP_CONFIG['password']
    end
  end
end

Una configuración de Replica Set quedaría de la siguiente manera:

<Server Host="192.168.1.214:27017,192.168.1.216:27017,192.168.1.14:27017"
               ReplicaSetName="devSet" MinReplicaServersToWrite="1" BalancedReading="true" PoolSize="50" WaitQueueTimeout="1"/>

host, definimos los servers de la replica set con su puerto separado por comas.

port, ha desaparecido se define en host.

ReplicaSetName, el nombre del replica set.

MinReplicaServersToWrite, a cuantos servidores de la replica hay que escribir como mínimo para devolver ok.

BalancedReading, si quieres leer de los secundarios.

Mail me si encontráis cualquier bug o pensáis en alguna mejora.

https://github.com/emiliotorrens/MongoMapper.NET

Passenger nos permite correr aplicaciones Ruby on Rails en nuestro servidor web Apache (o nginx).

Partimos en una maquina Ubuntu con Apache y curl instalado, lo primero es instalar el rvm y para eso ejecutamos el siguiente comando en nuestra consola:

bash -s stable < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)

Una vez instalado, tenemos que recargar en entorno, podemos cerrar sesión y conectarnos de nuevo, o ejecutar:

source ~/.bash_profile

Después tenemos que instalar el soporte SSL, eso es importante para instalar luego en passenger, si no tendremos que reinstalar todo otra vez, lo instalamos con este comando

rvm pkg install openssl

Ya tenemos el rvm instalado, ahora tenemos que instalar las versiones de Ruby que nos interesen, en este caso instalamos la 1.9.3, con soporte ssl, con este comando:

rvm install 1.9.3 –with-openssl-dir=$HOME/.rvm/usr

Así instalamos todas las versiones que queramos.

Para ver la lista de versiones instaladas

rvm list

Para ver cual estamos usando

rvm use

Para usar una

rvm use 1.9.3

Seleccionamos la versión que queramos usar e instalamos en passenger con este comando

gem install passenger

Cuando termine que instalarse hay que instalar el modulo de Apache, este modulo tiene unas dependencias, así que aquí dejo un comando para asegurar que tienes todas las dependencias:

sudo apt-get install libcurl4-openssl-dev; sudo apt-get install libssl-dev ; sudo apt-get install libopenssl-ruby ; sudo apt-get install apache2-prefork-dev ; sudo apt-get install libapr1-dev ; sudo apt-get install libaprutil1-dev ; sudo  apt-get install libopenssl-ruby

Con el passenger instalado y las dependencias solo nos queda instalar el modulo de Apache con

rvmsudo passenger-install-apache2-modulenan

Ojo aquí, cuando el modulo termine de instalarse te pondrá en pantalla 3 líneas que hay que añadir a la configuración del apache, será algo así:

Please edit your Apache configuration file, and add these lines:

   LoadModule passenger_module /home/administrador/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11/ext/apache2/mod_passenger.so
   PassengerRoot /home/administrador/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11
   PassengerRuby /home/administrador/.rvm/wrappers/ruby-1.9.3-p125/ruby

Tienes que modificar el apache2.conf y añadir esas 3 líneas al final del archivo, reinicias el Apache

sudo /etc/init.d/apache2 restart

Y listo, ya tienes el rvm y el passenger instalado, ya puedes poner tus aplicaciones ROR en el Apache

Nota, para instalar gems y esas cosas no hay que usar sudo hay que usar rvmsudo, de esta manera las gems se instalan en cada versión de Ruby, para ir cambiando de versión de Ruby ya lo hemos visto antes, rvm use la versión.