Ivan Arrizabalaga

If you are reading this surely you have found out that using AsyncAppender its not clearly documented and most of your google results lead you to some log4j 2.X.

Ok, in that case this is the right post for you.

Lets take an ordinary (synchronous) file logger from Log4j 1.x ( tested with 1.2.17) and wrap it up with a 'cool' AsyncAppender. :D.

Considering that you have

import org.slf4j.Logger
...
static Logger log = LoggerFactory.getLogger("MyLogger");

You turn your internal sync appender into an async with:

static {
  AsyncAppenderBuilder.wrapAsyncAppender(log, "MyAppndrName")
}

Then use just like a regular logger

The helping class looks like this:

Hope it helps!
Iván.

Maybe you have tried to config your Grails app so you can:

• Use the default logging configuration inside Config.groovy for test or dev.
• Use an external log4j.properties file in production.

It's quite frustating and it is not so well documented.
After some digging I came up with a quite elegant solution:

Config.groovy:
----------------------------

import grails.util.Environment

if(Environment.current!=Environment.PRODUCTION){
  // log4j configuration
  log4j = {
    ...
  }
}

resources.groovy:
----------------------------

import grails.util.Environment

if(Environment.current==Environment.PRODUCTION){
  log4jConfigurer(org.springframework.beans.factory.config.MethodInvokingFactoryBean) {
    targetClass = "org.springframework.util.Log4jConfigurer"
    targetMethod = "initLogging"
    arguments = ["classpath:resources/log4j.properties"]
  }
} 

log4j.properties (src/resources/log4j.properties):
----------------------------

  //whatever make sense to you

Please remember NOT to forget your imports or otherwise it wont work.

Hope it helps!

PD: Grails 3.0 is about to see the light and ...well who kows!. This solution is right for Grails 2.x family.

Como en js no hay clases reales cuando se quiere obtener un funcionamiento de delegación similar hay que acudir a patrones más o menos liosos para ello.

La forma más efectiva de hacerlo (en términos de memoría) es haciendo uso de los prototypes de las funciones tal y como sigue:



PD: Sacado del curso de Udacity-Object Oriented Javascript (https://www.udacity.com/course/ud015), si puedes hazlo.

En ocasiones necesitas poder cambiar fácilmente la versión actual de tu jdk para probar bajo diferentes JVMs.

Si solamente quieres actualizar la versión la mejor opción es usar un repo que te sirve las versiones más habituales (open, oracle, 6 y 7) y en este caso sólo tendrás que hacer lo siguiente:

 sudo add-apt-repository ppa:webupd8team/java
 sudo apt-get update
 sudo apt-get install oracle-java7-installer

Una vez descargadas/instaladas las versiones que necesites, en ubuntu sólo tendrás que usar:

update-java-alternatives

Si por el contrario tienes/quieres descargar las jvms a mano, basta con descomprimirlas en la ruta /usr/lib/jvm y a partir de ahi la historia es la misma tanto si vienes del repo como si has hecho la descarga manualmente.

Las versiones disponibles por defecto salen de los ficheros .XX.jinfo que están en la carpeta /usr/lib/jvm donde se debe descomprimir las diferentes maquinas virtuales que se quiera que esten disponibles.

El fichero .java-7-oracle.jinfo (por ejemplo) estará si haces la instalación con el repo, en caso contrario tienes que hacerlo tu mismo (busca por internet para saber que tienes que poner).

Ahora puedes ver las alternativas que estan "declaradas":

 sudo update-java-alternatives -l

 java-1.6.0-openjdk-i386 1061 /usr/lib/jvm/java-1.6.0-openjdk-i386
 java-7-oracle 1062 /usr/lib/jvm/java-7-oracle
 jdk1.6.0_45 1062 /usr/lib/jvm/jdk1.6.0_45

Y cambiar tanto java, javac, como toda su utileria a la opción deseada haciendo:

sudo update-java-alternatives -s jdk1.6.0_45

Normalmente con esto es suficiente y puedes comprobarlo haciendo:

 java -version
 java version "1.6.0_45"
 Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
 Java HotSpot(TM) Server VM (build 20.45-b01, mixed mode)

No obstante es posible que al intentar ejecutar la actualización de las variables que salgan un porron de mensajes como este:

 update-alternatives: error: alternative /usr/lib/jvm/jdk1.6.0_45/jre/bin/java for java not registered, not setting.

En este caso no tienes más opción que registrar las alternativas manualmente (lo mejor es hacer un pequeño script incluyendo todos los errores iguales):

sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jdk1.6.0_45/jre/bin/java" 1 --force

Tienes que tener en cuenta que el funcionamiento de las "alternatives" se basa en crear enlaces simbólicos (accesos directos) siguiendo el siguiente patrón:

/usr/bin/java -> 
/etc/alternatives/java -> 
/usr/lib/jvm/jdk1.6.0_45/jre/bin/java

Una vez arreglados esos problemas si vuelves a hacer el update-java-alternatives debería ir todo bien y la versión estaría perfectamente cambiada.

NOTA:

En algunos casos más allá de incluir los ejecutables en el /usr/bin hace falta declarar un JAVA_HOME.

Esto no lo has hecho con todo lo anterior así que si lo necesitas debes editarlo en /etc/environment:

JAVA_HOME="/usr/lib/jvm/jdk1.6.0_45"

Para que este cambio surga efecto debes hacer logout como mínimo.

Con los últimos anuncios de Graeme Rocher sobre la integración de Gorm en cualquier script Groovy:(ver https://gist.github.com/graemerocher/c25ec929d9bcd1adcbea):

Lo que pedía el cuerpo era hacer un intento para incluir Gorm en un ejemplo sencillo de Griffon.
El código completo esta en el siguiente repo (https://github.com/ivanarrizabalaga/BookGorm), y las partes relevantes son:

BuildConfig.groovy:

    repositories {


        griffonHome()


        mavenLocal()


        mavenCentral()


        mavenRepo "http://snapshots.repository.codehaus.org"


        mavenRepo "http://repository.codehaus.org"


        mavenRepo "http://download.java.net/maven/2/"


        mavenRepo "http://repository.jboss.com/maven2/"


        mavenRepo "http://repo.spring.io/milestone"


        mavenRepo "http://repo.spring.io/release"        


    }


    dependencies {


        runtime "org.grails:grails-datastore-gorm-hibernate4:3.0.0.RELEASE"


        runtime "org.grails:grails-spring:2.3.6"


        runtime "com.h2database:h2:1.3.164"        


        compile "org.springframework:spring-expression:3.2.4.RELEASE"        


    }

Initialize.groovy:

//TODO Should be a Spring bean


new HibernateDatastoreSpringInitializer("bookgorm").


configureForDataSource(new DriverManagerDataSource(


Driver.name, 


"jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE", 'sa', ''


)


)

src/main/bookgorm/Book.groovy:

package bookgorm


import grails.persistence.Entity













@Entity


class Book{


  String title


  String author


  static constraints = {


        title blank:false


        author blank:false


  }


}

BookController.groovy:

    void loadData(){


        List books=Book.list()


        edt{


            model.books.addAll(books)


        }


        


    }




    def addBook= {evt=null->


        Book b=new Book(title:view.titleField.text,author:view.authorField.text)


        b.save()


        edt{


            model.books.add(b)


            view.titleField.text=""


            view.authorField.text=""


        }


    }




    def clearAll= {evt=null->


        Book.executeUpdate("delete Book")    


        edt{


            model.books.clear()


        }


    }    

Mola, no?
¡A cuidarse!

How should I do in order to reuse my domains?
Use your own domain's plugin, this is how.

Just create your plugin:

grails create-plugin book-remote
...{work as usual with your domains}...

Change your groupId/version and set binary as default type of packaging:

BookRemoteGrailsPlugin.groovy:

String groupId = 'com.nortia.book'
String version = '0.1'
String packaging = 'binary'

Install into local maven repo (or wherever you want to):

grails  maven install --binary

Then, you have include your plugin as a dependency for your grails app:

BuildConfig.groovy:

    dependencies {
    //Since it is  binary plugin is goes here instead of in the 'plugins' section
compile 'com.nortia.book:book-remote:0.1'
    }

That's it! :D
PD: There is no need for the plugin to be 'binary' unless you're planning to use those domains in another groovy (no grails) project (which was my case).

Llevo meses usando una especie de servilleta vieja donde apunto los comandos básicos de Git que siempre se me olvidan.

Hoy tenía que recoger la habitación y aunque no descarto que la hoja en cuestión acabe teniendo valor histórico creo que es momento de volcarlo a un mini-post que me sirva como 'cheatsheet' personal.

Hay 1000 recursos por ahi fuera mucho más estructurados y más completos, esto es simplemente mi versión ultrasimplificada

Los comandos hacen referencia a un hipotético escenario donde se trabaja sobre 3 entornos (desarrollo, staging, produccion), desplegando la aplicación sobre Heroku.

En groovy convertir las propiedades de un objecto en un Map es una labor practicamente inmediata:


Nota: Si el objecto no es un objeto simple sino que esta compuesto de otros objetos complejos estos campos serán mapeados igualmente pero tal cual son, sin transformarse en Maps.

O como hacer un update en una tabla según una condicion que involucre a una segunda tabla. Por ejemplo si tenemos:

tablaPadre (id, tablaHija_id)
tablaHija(id,tablaPadre_id)

Y resulta q por un error de carga o algo similar la columna tablaPadre_id no esta bien cargada, podemos actualizar esa tablaHija según los datos de la tablaPadre usando la siguiente query:

UPDATE tablaHija th
SET tablaPadre_id = (
   SELECT t.id
   FROM tablaPadre tp
   WHERE tp.tablaHija_id = th.id)
WHERE EXISTS (
   SELECT 1
   FROM tablaPadre tp
   WHERE tp.tablaHija_id = th.id);

De esta forma los valores de la columna de la tablaPadre se usarán para dar valor a la columna vacia de la tablaHija.

Ale, chao!

Si alguna vez te has visto obligado a hacer un 'Replace All' en un fichero de texto grande (> 500MB) sabras que la experiencia es casi religiosa.

El editor de turno se queda colgado al abrir y al reemplazar y no queda dios ni semidios del que no te hayas acordado.

La solucion pasa por usar el comando sed de linux:

sed -i.bak 's/datamart_desa/datamart/' fich.sql

En este ejemplo se reemplaza la cadena "datamart_desa" por "datamart" en el fichero 'fich.sql' generando (por si acaso) un backup con el nombre 'fich.sql.bak'.

En un ejemplo concreto con un fichero de 870MB tarda unos 10sec., ¡una maravilla oiga!

De nada, :D

Como se puede listar las tareas/procesos de windows desde línea de comandos?

tasklist

Como se puede matar un proceso a partir de su id?

Taskkill /PID 756 /F

De nada! :D.

A veces, en especial mientras ejecutas tests, necesitas sacar la información de tus objetos de dominio.

Empiezas con un println sencillo y al rato tu código apesta porque tienes println infumables que además habrá que revisar el día que cambias la definición de tus clases.

Así que para ahorrarme estos disgustos he acabado haciendo una clase muy sencilla que directamente te permite sacar la información de cualquier dominio (o listas de dominios) de forma genérica.

El código mezclando groovy con la api de reflection de java queda como sigue:


Si vas por partes verás que es muy sencillo, el único detalle más complicado tiene que ver con los campos heredados ya que hay que escalar en la jerarquía para poder listarlos.

Ale, espero que le sirve a alguien!
Iván.

Right to the snippet, :D

Cuando en vez un input normal se quiere garantizar que la entrada cumple un formato o tipo de valor específico hace falta irse a su hermano 'raro' el JFormattedTextField.

Para conseguir que funcione bien en Griffon lo primero es entender correctamente como funciona en Java, así que tal vez debas echar un ojo a este enlace:

http://docs.oracle.com/javase/tutorial/uiswing/components/formattedtextfield.html

Aunque siendo realista, es posible que no te apetezca leer tanto así que te pongo un ejemplo básico y listo, :D.

En este ejemplo vamos a ver como se hace el binding de valores de un formattedTextField:


Model:


View:


A partir de ahi cualquier necesidad diferente pasará casi siempre por jugar con el NumberFormat para crear la máscara adecuada y demás historias.

Ale, que la fuerza te acompañe!

En la historía de la humanidad siempre ha habido guerras, seguramente este en nuestra genética, no sabemos estarnos quietecitos.

Al principio algunos luchaban por su libertad:



más adelante muchos lucharon contra muchos:



y así hasta nuestros días.

El caso es que poco a poco intentamos ser más civilizados (aunque honestamente no lo conseguimos demasiado) así que para la próxima guerra ya se están reclutando los nuevos soldados y muchas de las balas serán sockets, callbacks y raspberrys.

¿Quée?
Pues eso, en los próximos años se librarán muchas batallas, algunas tendrán pocos muertos pero muchas victimas (económica o socialmente hablando) y cada frente se está preparando para ello.

En Corea, China, Japón y similar, los niños son presionados por sus padres y profesores para ser la mejor versión de si mismos intelectualmente hablando y en vez de futbolistas muchos de esos pezqueñines sueñan con hacer saltar la banca.

En vista de esto US ya se ha puesto manos a la obra y no quiere quedar atrás de ningún modo, haciendo un llamamiento a la juventud a que se aliste al frente y haga fuertes sus trincheras:



Mola, ¿no?
Pues figurate si te lo pide Shakira, Asthon Kutcher o similar:



Y es que encima, estos frentes de nueva creación no entienden de nacionalidades, si quieres te puedes unir al frente de Coders Lapones, eso depende ti y tu habilidad.

El caso es que está oportunidad no ya puede dejar pasar España y ya se han puesto manos a la obra toda la piara de asesores de nuestros mandatarios para contrarrestar estas iniciativas y mover a nuestros jóvenes al futuro:


Podemos estar tranquilos, nos van a dar tal paliza que no nos dolerá.

Es posible que quieras mantener varias versiones de Griffon disponibles en tu Ubuntu y te habrás preguntado como se puede hacer eso. 

La opción más 'pro' sería basarse en el uso de 'update-alternatives' pero como buscamos algo realmente sencillo vamos a tirar de enlaces simbolicos.

Al tema:

Descomprimir el tar/zip en la carpeta /usr/share

Irse a la carpeta de comunes:

cd /usr/share

Asegurarse que la carpeta y sus archivos tienen el mismo user/group que el resto de 'ejecutables':

sudo chown -R root:root griffon-1.2.0

Actualizar/Crear (si es la primera vez) el enlace simbolico a la version que queramos:

ln -sfn griffon-1.2.0 griffon

Actualizar/Crear 3 enlaces simbólicos a los scripts principales de Griffon desde el bin para que este accesible en el path:

 /usr/bin/griffon -> /usr/share/griffon/bin/griffon 
 /usr/bin/griffon-debug -> /usr/share/griffon/bin/griffon-debug
 /usr/bin/griffonsh -> /usr/share/griffon/bin/griffonsh

Para comprobar que esta todo correcto podemos hacer desde cualquier carpeta:

 griffon -version 
------------------------------------------------------------
 Griffon 1.2.0
------------------------------------------------------------

y debería salir la versión a la que estemos apuntando.

Como última nota recordar que siempre que hay un 'ejecutable' en el path podemos recordar de donde sale haciendo:

 which griffon
 -->/usr/bin/griffon

A veces es necesario comprobar que una cadena no contiene ninguno de los términos "prohibidos" de una lista.

En este caso lo fácil es hacer un pequeña función con un bucle y a correr, pero como esto es Groovy y somos más guays queremos hacer que la clase String tenga un método que nos resuelva la papeleta para no ir llenando nuestro código con funciones de este estilo o en el menos malo de los casos creando una clase helper con un método estático o alguna cosa así.

Así que al lio:



El truco aqui esta en usar la inyección de métodos del metaClass por un lado y sobre todo sacar provecho de la función inject que está disponible para listas.

Esta función lo que hace es ejecutar un closure sobre cada elemento de la lista arrastrando el valor de la ejecución en cada elemento hacia el siguiente.

Mola verdad? :D

Aunque parezca mentira ("me pongo colorada..."), no en serio, aunque no te lo creas añadir un elemento a una lista de groovy puede resultar peligroso.

Las siguientes instrucciones no hacen lo mismo siempre:

output+=item
output.add(item)

Si el elemento es una lista la primera operacion implica añadir los elementos de la lista y la segunda inserta en la lista destino un objeto de tipo lista.

Si no te lo crees chequea esto:

Ale, a seguir grooveando con cuidado!

A veces a partir de una lista de elementos se pide poder "subir" o "bajar" una subselección de tu lista.

Es una operación que se puede hacer de muchas formas, pero en groovy se puede jugar un poco con el lenguaje para que sea más chulo el código y sobretodo para poder usar lo mismo en ambas direcciones.

Ale, ahi va...

Sometimes you need to change an specific string not only in one column but in each and every column all along your database. If you are in this circumstance this little snippet might help you: It simple creates a bunch of updates by scanning all string columns (var, varchar) all through the database. Hope it helps!

In groovy you can easily access properties by using GString which a really cool feature.


However this trick doesnt work when nested '.' are inside de expression.

In this case you can do the following:

That's all!

Spring hace aveces magia negra, lo cual está muy bien salvo cuando no funciona y tienes que pararte a mirar que coño de hechizos está usando, :D.

El caso es que si tienes problemas con la gestión de transacciones delegadas a las anotaciones de Spring es probable que quieras hacer un test unitario para ver si las conexiones se cierran o no.

Como configurar el test de groovy para que ejecute la política de transacciones que quieras?

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = ["classpath:/beans/misBeans1.xml","classpath:/beans/misBeans2.xml"])
@TransactionConfiguration(transactionManager="transactionManager", defaultRollback=false)
class SpringConnectionsTest{

 static final Logger log=Logger.getLogger(SpringConnectionsTest.class)

 @Autowired
 ApplicationContext context;

@Before
void setTup(){
....
}

@Test
void testSomething(){
...
}

• Así que basicamente se trata de quitar la herencia al GroovyTestCase que tendría por defecto al ser un test de groovy.
• Indicar los ficheros de beans que se quieren cargar.
• Inyectar el bean (en el ejemplo cogemos el contexto podría ser cualquier bean) con @Autowired.

Como podemos ver que métodos se registran para el control de transacciones?

log4j.logger.org.springframework.transaction=DEBUG

Cómo podemos ver cuándo se pilla una conexion nueva o se reutiliza una?

log4j.logger.org.springframework.jdbc.datasource.DataSourceUtils=DEBUG

Mi método no lo engancha, ¿qué pasa?

Podrían ser 1000 cosas, pero recuerda que el transactionManager solo funciona con métodos públicos.  

Cuando manejamos un Tomcat instalado en un servidor Linux personalizar las opciones de memoria (heap mínima, máxima, permsize, ..) se reduce a meter las variables o bien en las variables de entorno (JAVA_OPTS, CATALINA,OPTS) o bien a modificar el script de arranque directamente.

Sin embargo cuando el servidor es un Windows y el Tomcat está instalado como servicio la cosa difiere un poco de lo habitual, y la verdad, cuesta un poco encontrarlo.

En este caso en la carpeta

TOMCAT_HOME\bin

hay un ejecutable Tomcat6w.exe que permite lanzar una herramienta para arrancar/parar/reiniciar el servidor y a su vez cambiar la configuración de paramétros del servicio.

Si la arrancamos tiene una pestaña donde se puede configurar todo lo referente a la memoría y resto de parámetros, una imagen vale más que 1000 palabras:

 

Cuando se crea un MVC a través de una de las variantes de:

def mvc=buildMVCGroup([arg1:value1,arg2:..],"pintador")

es fundamental entender el proceso interno que lleva a la correcta construcción del MVC. El proceso se ejecuta en 3 fases y en cada de ellas se sigue por defecto el orden lógico (modelo, vista y finalmente controlador *), la secuencia es como sigue:
 


La primera fase invoca al constructor de cada una de las partes, por ejemplo:

PintadorController(){
 ...
 }

La segunda fase invoca a los setters de los objetos según los parámetros que se hayan pasado al invocar el buildMVCGroup, por ejemplo:

class PintadorModel{
 def arg1
 ...
 void setArg1(def cosa){
 this.arg1=cosa
 }

Es importante subrayar que sólo se invoca al setter si los nombres entre el argumento y la propiedad coinciden. Finalmente se hace el paso de 'postproducción', llamandose al mvcGroupInit de cada artefacto.

void mvcGroupInit(Map args) {
 ...
 }

Un truco importante aqui es que el pintado de la pantalla (es decir la ejecución del script PintadorView.groovy en nuestro ejemplo) se realiza en esta última etapa después del mvcGroupInit del modelo (PintadorModel.groovy) lo cual permite hacer uso de bucles limpios en el propio script si fuera necesario algún tipo de calculo añadido sobre el modelo antes de mostrarlo:

//File: PintadorModel.groovy
 class PintadorModel{
 def arg1
 def objetos
 void mvcGroupInit(Map args){
 objetos=server.getObjetos(arg1)
 }
 }
 ...

//File: PintadorView.groovy
 ...
 vbox(){
 model.objetos.each{
 label $it
 }
 }

Listo! A partir de ahora hacer mvcs no debería tener ningún secreto.

*Nota:

En realidad este orden es así por defecto dado que en la declaración del mvc en el fichero Application.groovy se sigue ese orden, si el orden fuera:

mvcGroups {
 'pintador' {  
   model = 'com.mycompany.PintadorModel' 

   controller = 'com.mycompany.PintadorController' 

   view = 'com.mycompany.PintadorView' 
 } 
 .... 
}

el orden de invocación de los artefactos sería ese para cada una de las tres etapas.