OpenShift, the future is comming

We have an old application (quinigold) hosted in Tomcat 3.X.
The application is very simple and it is a project final degree, and adminitration football pools. (http://goldbittle.dyndns.org/index.html )

We thought about migration to GAE (Google AppEngine) but we listened to a fantastic podcast from Juan Noceda and JavaHispano.

And them we make a pros-contra


GAE (Google Aplication Engine)

     Pros
         For free according to consumption
         We can take advantage of the whole subject of SingleSignOn google.
         mature technology, documentation and examples
         integrated with eclipse

     Cons
         Proprietary technology with reference to DB
         A subset of Java technology specifications ex: you can not call java.net.URL
         Possible problems with WS, REST technology watch

  OS (OpenShift )

     Pros
         pure java
         what works in linux works openshift
         INTEGRATION with eclipse
         Adding services (mysql, ....)

     Cons
         the price is not clear
         very new technology, some examples
         see the integration
         learn new versioning (GIT)   

Now, is time for change.
We want pure Java (OS+1)
We want integration WebServices (OS+1)
We want free developing and free quota (GAE+1, OS+1)
We want mysql export-import BBDD (OS+1)


The result:  OS win.


The OpensShift is considered the best.

 

configurar tonos de pantalla del ordenador

F.lux ayuda a descansar la vista

http://stereopsis.com/flux/

en referència a: F.lux: software to make your life better (visualitza-la a Google Sidewiki)

Distribuïnt...: El Ecosistema Hadoop.

Distribuïnt...: El Ecosistema Hadoop.:

Copia literal del blog de http://distribuint.blogspot.com/

El Ecosistema Hadoop.

Hadoop es sin duda uno de los proyectos que más acogida últimamente ha tenido entre la comunidad de software libre y es también uno de los responsables del auge de la ciencia de datos.
Hadoop es un framework, aunque hoy en día se puede hablar de todo un ecosistema de proyectos alrededor del nucleo, vamos a intentar explicar en este post los distintos componentes de forma senzilla:


vamos a empezar por el principio,


Hadoop
Con Hadoop nos referimos a la parte central del sistema, que es el sistema de ficheros distribuido (HDFS) y el motor de Map/Reduce. Si echamos un vistazo a la página del proyecto veremos que hay 3 subproyectos, calma y tranquilidad!, a efectos prácticos van totalmente juntos y es una separación que se hizo por temas de código fuente:

• Hadoop MapReduce.
• HDFS.
• Hadoop - Commons.

Una vez aclarado el tema de la separación. Qué es Hadoop? Pues es la combinación de:

• un sistema de ficheros distribuido (diferentes discos duros en diferentes máquines se ven como uno solo) (HDFS)
• de un modelo de programación que se llama Map/Reduce, con su API en Java (Hadoop MapReduce)
• y un componente software que ejecuta los programas que hemos programado con la API en un cluster, usando asi el sistema de ficheros distribuido.
• y una serie de classes comunas (Hadoop - Commons)

Esto es lo básico que debemos instalar en el clúster para obtener la funcionalidad. De este modo podemos meter datos en el sistema de ficheros y tratarlos con nuestros programas programados con el API de Hadoop.

Vamos a ver qué más hay:

HBase

Una vez tenemos los datos procesados en Hadoop seguramente nos interesará tenerlos fácilmente accesibles para diferentes tipos de consultas, algo así como una base de datos con los resultados de Hadoop. Aquí es donde entra HBase.

HBase es una implementación libre del Bigtable de Google, es una de las famosas bases de datos NoSql. Como el nombre indica, no usa Sql, sinó que tiene una API, además el model de datos no es tabular, sinó que está basado en columnas de n dimensiones. Ya hablé de este modelo de datos en un post anterior.

A efectors prácticos, se tratan los datos en Hadoop mediante Map/Reduce y se escriben en HBase (importante saber que HBase está totalmente integrado con Hadoop, y que por lo tanto, HBase entiende perfectamente el sistema de ficheros de Hadoop asi como el formato de los ficheros), que puede estar en el mismo clúster que Hadoop o en otro, para que otras aplicaciones puedan utilizar los datos en tiempo real.

Zookeeper
Tanto HBase como Hadoop son sistemas distribuidos en los que el sistema debe controlar y saber en cada momento lo que está pasando en procesos que están en otras máquinas. Si hemos programado alguna vez este tipo de sistemas sabremos que eso no es una tarea fácil, nos vamos a encontrar todo tipos de problemas.

Zookeeper aparece justamente para solucionarlos. Igual que HBase es la implementación libre de un paper de google, en este caso de Google Chubby.

Básicamente es un sistema de locks distribuido y de consenso (utilizando Paxos), no hace mucho los ingenieros de LinkedIn lo usaron para un sistema interno y hicieron un post muy interesante, en el que utilizaron la siguiente definición, muy acertada en mi opinión:

ZK has a very simple, file system like API. One can create a path, set the value of a path, read the value of a path, delete a path, and list the children of a path. ZK does a couple of more interesting things:

(a) one can register a watcher on a path and get notified when the children of a path or the value of a path is changed,

(b) a path can be created as ephemeral, which means that if the client that created the path is gone, the path is automatically removed by the ZK server.

de: http://sna-projects.com/blog/2010/08/zookeeper-experience/

Asi que ya tenemos otra pieza del puzzle, si hay que sincronizar sistemas distribuidos (que utilizen o no Hadoop), podemos utilizar ZooKeeper.

Ahora toca el turno de hive, pero atención porqué después viene pig y aunque vamos a ver que son bastante diferentes, los dos proyectos pretenden solucionar un problema muy similar:



Hive
La principal incomodidad que tiene Hadoop es que para hacer una simple consulta de datos hay que escribir un programa completo en Java, y esto, no es rápido, es un poco difícil de debuggear y puede llegar a ser frustrante.

Pongamos el caso en que tenemos 500 Gb de datos del tipo:

Key: Integer
Value: Objecto(Id: Integer, valor1: Integer, valor2: Integer)

y que en un momento dado queremos un listado de todos los pares Key/Value dónde valor2 > 500.

Si los datos estuvieran guardados en una base de datos podriamos hacer una senzilla consulta Sql con un where. En Hadoop tocaría escribir un programa en Java. Pues bien, Hive al rescate.

Se trata básicamente de una infraestructura de data warehousing encima de Hadoop. Y esto que significa? pues básicamente se trata de crear unos metadatos encima de los directorios de HDFS describiendo el formato de los ficheros, asi pues creamos una estructura tabular virtual encima de Hadoop. Hive también tiene un intérprete de comandas sql, por lo tanto podemos escribir una consulta sql de toda la vida en la command line, luego hive coge el sql, lo convierte automáticamente en jobs Map/Reduce y estos son ejecutados de forma transparente en el clúster como jobs normales.


Si quereis más información, anteriormente hice un post hablando de hive con más detalle.


Pig
Otro modo de ver el anterior problema es: en vez de escribir un programa en Java para hacer una consulta de unos datos, voy a hacerlo con nserta aquí tu lenguaje de scripting favorito>. Hadoop tiene como parte del Hadoop Core una opción de streaming. Básicamente te permite especificar como parámetro dos scripts (uno que hace de mapper y otro que hace de reducer) que leen y escriben por la entrada y salida estándar. Esto es práctico pero te limita a unos programas muy sencillos y poco aplicables a la vida real.

Pues bien, Pig es un lenguage de programación (tipo scripting) para Hadoop, y por lo que estoy viendo parece que tiene una muy buena aceptación en la comunidad Hadoop (pero que muy buena aceptación).

Avro
Una de los puntos fuertes del ecosistema Hadoop es que facilita trabajar con grandes cantidades de datos. Estos datos están guardados en el HDFS, pero cómo? pues se pueden guardar en diferentes formatos, el más simple es el de texto plano, pero normalmente se recomienda usar serialización.


Qué es la serialización? pues se trata de como almacenamos la información internamente de un objeto a disco (o memoria), podemos leer más en la wikipedia. Para Hadoop lo más interesante son los formatos binarios, que son los más rápidos y comprimidos, el problema es que un humano no los puede leer, pero en este caso no nos importa.


Tenemos diferentes formatos:

• Protocol Buffers, creado por Google.
• Thrift, creado por Facebook.

y otros dos, creados por los programadors de Hadoop:

• RecordIO: Hasta hace pronto el formato de serialización de facto en Hadoop, bastante interesante en su implementación, pero con algunos problemas en temas de mantenimiento a largo plazo (los objetos generados son estáticos, esto significa que si modificamos las características del objeto (introducimos un nuevo campo) el objeto nuevo será incompatible con el viejo). Si echamos una ojeada a la documentación veremos que está deprecated by... si señor:
• Avro.

Tiene unas características muy interesantes, básicamente:

• Permite almacenar estructuras de datos simples y complejas (desde números hasta objectos con listas y maps)
• Es compacto, rápido y binario. (Esto no es mucha novedad)
• Tiene un format de fichero propio.
• Tiene una especificación de RPC. (como Thrift)
• Y lo más interesante: El esquema de serialización (el índice que dice que tipo de datos está en cada posición del fichero) está incluido en el fichero en si. Esto permite que la generación de código por parte del precompilador sea opcional y lo que es más importante, hace que podamos canviar la estructura interna de los objectos almacenados sin perder la compatibilidad con ficheros viejos.

Por lo tanto, si trabajais con Hadoop, a serializar los datos con Avro desde ya.

Flume
The "new kid in town". Flume fue liberado por Cloudera no hace ni medio año y ya ha tenido una gran adopción.

La idea es muy sencilla, se trata de una pipe al HDFS.
Lógicamente para trabajar con Hadoop debemos tener los datos en el HDFS, y tenemos diferentes herramientas para poner los ficheros allí, el problema es que cuando tenemos diferentes fuentes de datos (el syslog de muchos servidores web por ejemplo) hay que construir una infraestructura que se asegure que los logs se van subiendo periódicamente y que no falte ninguno. Pues bien, Flume es exactamente esto. Además utiliza ZooKeeper, por lo tanto es:

• tolerante a fallos ( si un nodo cae de la red, cuando se vuelva a conectar sabrá que tiene que enviar de nuevo ),
• tiene configuración distribuida (puede reconfigurar los nodos cliente a partir de un nodo máster)

Y no se acaba aquí! hay más, mucho más en Hadoop, pero creo que estos son los proyectos más interesantes y que estás más ligados a Hadoop.

BEA - Weblogic Deploying Applications

in cluster environment and NAS common, is prefer deploying in nostage mode, that all the share files and not necessary do a copy.


Deploying Applications and Modules: "

# Nostage mode—The Administration Server does not copy the archive files from their source location. Instead, each targeted server must access the archive files from a single source directory for deployment. For example, if you deploy a J2EE Application to three servers in a cluster, each server must be able to access the same application archive files (from a shared or network-mounted directory) to deploy the application.

Nostage mode is the default mode when deploying only to the Administration Server (for example, in a single-server domain). You can also select nostage mode if you run a cluster of server instances on the same machine.

aixs_https

Introducció

---

Utilització d’un client axis per consumir un webservice per https.

.

Descripció i solució del problema

---

1. Generar les clases d’axis mitjançant ant.

    Utilitzar l’url sense securitzar (http)

       <property name="wsdl.url" value="http://domini/AppJava/ws/documentService?wsdl" />
       <axis-wsdl2java output="${sourceDir}/auto-generated" testcase="false" verbose="${verboseProp}" url="${wsdl.url}" debug="${verboseProp}" all="true" />

• Crear una clase que extengui de JSSESocketFactory

import java.io.IOException;

import java.io.InputStream;

import java.security.KeyStore;

import java.security.SecureRandom;

import java.util.Hashtable;

import javax.net.ssl.KeyManagerFactory;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.TrustManagerFactory;

import javax.net.ssl.X509TrustManager;

import org.apache.axis.components.net.JSSESocketFactory;

import org.apache.axis.components.net.SecureSocketFactory;

import org.apache.commons.lang.StringUtils;

/**

* Custom SSL socket factory to use our integrated keystore.

*

* Based loosely on org.apache.axis.components.net.SunJSSESocketFactory

*/

public class DTSSLSocketFactory extends JSSESocketFactory implements SecureSocketFactory {

    public DTSSLSocketFactory(Hashtable attributes) {

   super(attributes);

    }

    /* local keystore password */

    private static String MY_KEYSTORE_PASSWORD = "12345678";

    /* local keystore file (contains the self-signed certificate from the server */

    private static String RESOURCE_PATH_TO_KEYSTORE = "pre_electia.jks";

    /**

    * Read the keystore, init the SSL socket factory

    *

    * This overrides the parent class to provide our SocketFactory

    * implementation.

    *

    * @throws IOException

    */

    protected void initFactory() throws IOException {

   try {

       SSLContext context = getContext();

       sslFactory = context.getSocketFactory();

   } catch (Exception e) {

       if (e instanceof IOException) {

       throw (IOException) e;

       }

       throw new IOException(e.getMessage());

   }

    }

    /**

    * Gets a custom SSL Context. This is the main working of this class. The

    * following are the steps that make up our custom configuration:

    *

    * 1. Open our keystore file using the password provided 2. Create a

    * KeyManagerFactory and TrustManagerFactory using this file 3. Initialise a

    * SSLContext using these factories

    *

    * @return SSLContext

    * @throws WebServiceClientConfigException

    * @throws Exception

    */

    protected SSLContext getContext() throws Exception {

   char[] keystorepass = MY_KEYSTORE_PASSWORD.toCharArray();

   if (StringUtils.isBlank(new String(keystorepass)))

       throw new Exception("Could not read password for configured keystore!");

//    InputStream keystoreFile = this.getClass().getResourceAsStream(RESOURCE_PATH_TO_KEYSTORE);

   InputStream keystoreFile = Thread.currentThread().getContextClassLoader().getResourceAsStream(RESOURCE_PATH_TO_KEYSTORE);

   if (keystoreFile == null)

       throw new Exception("Could not read the configured keystore file at " + RESOURCE_PATH_TO_KEYSTORE);

   try {

       // create required keystores and their corresponding manager objects

       KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

       keyStore.load(keystoreFile, keystorepass);

       KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());

       kmf.init(keyStore, keystorepass);

       TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

       tmf.init(keyStore);

       // congifure a local SSLContext to use created keystores

       SSLContext sslContext = SSLContext.getInstance("SSL");

        TrustManager[] trustAllCerts = new TrustManager[] {

                   new X509TrustManager() {

                         public java.security.cert.X509Certificate[] getAcceptedIssuers() {

                            return null;

                         }

                         public void checkClientTrusted(

                            java.security.cert.X509Certificate[] certs, String authType) {

                         }

                         public void checkServerTrusted(

                            java.security.cert.X509Certificate[] certs, String authType) {

                         }

                      }

                };

       

//        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());

       sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

       return sslContext;

   } catch (Exception e) {

       throw new Exception("Error creating context for SSLSocket!", e);

   }

    }

}

• Creació del jks del certificat del domini

• Exportar la clau pública del domini com format PEM

• 
  

• Amb l’eina keytoolui crear un magatzem .jks i donar-li un pwd

• Importar la clau pública del servidor (importar el pem cap al magatzen .jks)

• Executar el servei

    WSDocumentBoLocator locator = new WSDocumentBoLocator();
locator.setWSDocumentBoHttpPortEndpointAddress("https://domini/AppJava/ws/documentServicel");
   AxisProperties.setProperty("axis.socketSecureFactory", "DTSSLSocketFactory_nom de la clase feta en el punt anterior");
   WSDocumentBoPortType service = locator.getWSDocumentBoHttpPort();

---

Referències

---

• http://www.pankaj-k.net/WSOverSSL/WSOverSSL-HOWTO.html

• http://www.brothersoft.com/keytool-iui-for-windows-90269.html

• 
  

jmeter-amf-visualizer

The visualizer deserialize response in text. It's similar to AMFExplorer, plugin FF (https://addons.mozilla.org/en-US/firefox/addon/78928/)

Just copy the JAR file (org.racsor.jmeter-0.0.1.jar) into JMeter's lib/ext directory.

If you want test with JMeter you could execute doc/testJMeter-jmx/tourFlex.jmx and modified filesSystempath with your path to POSTXXXXX.binary


jmeter-amf-visualizer - Project Hosting on Google Code: "

Problem with Java Client (Web Services) org.xml.sax.SAXException: Bad envelope tag: definitions

When generate a client Axis from wsdl and execute the problem is:

org.xml.sax.SAXException: Bad envelope tag: definitions


The locator is bad definition with:

locator.setConsultesClioHttpPortEndpointAddress("http://127.0.0.1/sgr_ws/AppJava/services/consultesClio?wsdl");



The correct way is (without wsdl:

locator.setConsultesClioHttpPortEndpointAddress("http://127.0.0.1/sgr_ws/AppJava/services/consultesClio");









Problem with Java Client (Web Services forum at JavaRanch): "