El pasado 2 de Julio celebramos una reunión de Agile-canarias en la que se realizó un juego ágil , impartido por Yeray Darias y Gregorio Mena. También en esa reunión Yeray habló sobre las técnicas Pomodoro y yo un poco sobre GIT vs SVN. Incluyo la presentación.

DesconferenciaGIT

Hasta la siguiente reunión

Primera parte

Segunda parte

Durante estos días he tenido que conectar un servidor Apache 2.2.14 con un Tomcat 6, para realizar pruebas. Tras leer un montón de páginas que explican como hacerlo he creado una “chuleta” que ahora comparto con todos.

Paso seguidos:

1. Descargo desde http://apache.rediris.es/tomcat/tomcat-connectors/jk/binaries/linux/jk-1.2.28/i586/ el mod_jk para apache 2.2.x

2. Copio en modules de apache el mod_jk.so

3. Creo en conf el fichero mod_jk, que indica donde cargar el .so descargado, el fichero de workers.properties
Teniendo el aspecto

# Load mod_jk module
# Update this path to match your modules location
LoadModule jk_module modules/mod_jk.so
 
# Where to find workers.properties
# Update this path to match your conf directory location
JkWorkersFile conf/workers.properties
 
# Where to put jk logs
# Update this path to match your logs directory location
JkLogFile logs/mod_jk.log
 
# Set the jk log level [debug/error/info]
JkLogLevel info
 
# Select the log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
 
# JkOptions indicate to send SSL KEY SIZE,
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
 
# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"
 
# Send everything for context /ws to worker ajp13
JkMount /ws ajp13
JkMount /ws/* ajp13
 
# Send everything for context /jsp-examples to worker ajp13
JkMount /jsp-examples ajp13
JkMount /jsp-examples/* ajp13
 
# Send everything for context /servelts-examples to worker ajp13
JkMount /servlets-examples ajp13
JkMount /servlets-examples/* ajp13

Con JkMount indicamos que cuando se indique esa ruta en el apache se redirija la petición al tomcat para que resuelva la petición.

4. Crear el workes.properties, donde se indica como conectar con el tomcat

# Define 1 real worker named ajp13
worker.list=ajp13
 
# Set properties for worker named ajp13 to use ajp13 protocol,
# and run on port 8009
worker.ajp13.type=ajp13
worker.ajp13.host=localhost
worker.ajp13.port=8009
worker.ajp13.lbfactor=50
worker.ajp13.cachesize=10
worker.ajp13.cache_timeout=600
worker.ajp13.socket_keepalive=1
worker.ajp13.socket_timeout=300# Define 1 real worker named ajp13
worker.list=ajp13

Con este fichero podemos indicar todas la conexiones a los tomcats que resolverán las peticiones.

5. Luego en conf\server.xml del Tomcat habilitar la conexión ajp13 en el tomcat, en este fichero descomentar esta linea

<!-- Define an AJP 1.3 Connector on port 8009 -->
<Connector port="8009" enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

Esta parte es importante porque con esto indicamos al tomcat por que puerto escucha para atender conexiones, así el valor de port debe ser el mismo de worker.ajp13.port
6. Incluyo el fichero con del mod_jk.conf en el httpd.conf de apache

include conf/mod_jk.conf

Webs usadas

• Apache 2 with Tomcat 6

El pasado 4 de Junio celebramos una reunión de Agile-canarias en la que se realizó un taller de integración continua, impartido por Yeray Darias y Fran Reyes

Para no perder el hilo de lo que se relata en esta entrada se irán enlazando los artículos sobre el taller.

Hasta la siguiente reunión el 2 de Julio de 2010.

Primera parte

Seguna parte

Tercera parte

Cuarta parte

Quinta parte

Sexta parte

Séptima parte

El pasado 27 de Mayo celebramos una reunión de Agile-canarias en la que tratamos sobre las pizarra kanban y así hablamos sobre como aplicar el cambio en la empresa.

Hasta la siguiente reunión el 4 de Junio de 2010.

Primera parte

Segunda parte

El día 10 y 11 de Junio se celebrará en Madrid la primera conferencia sobre metodologías ágiles en España

Para más información pueden visitar el blog oficial CAS2010

Por varias razones he tenido que procesar un fichero en CSV sencillo y para ello me aproveche de ciertas facilidades de Groovy. A continuación pongo el código utilizado.

Código de la clase de dominio que almacena:

class Pais {

 def descripcion

}

Código del procesado:

def pathTemporal =  System.getProperty("java.io.tmpdir")

def pathFichero = pathTemporal + '/pais.csv'

def fich = new File (pathFichero)

def array = fich.readBytes()

def cadena = new String (array)

def lista = cadena.replace('\n','#').tokenize('#')

def patron = []

def primera = true

lista.each {linea->

    def lineaProcesada = linea.tokenize(';')

    if (primera == true) {

        patron = lineaProcesada

        primera = false

    } else {

        def mapa = [:]

        def valores = lineaProcesada

        def i = 0

        patron.each{clave->

            if ((clave?.trim()?.size() > 0) || (valores[i]?.trim()?.size() > 0)) {

                mapa."$clave" = valores[i]

                i++

            } 

        }

        def temp = new Pais (mapa)

    }

}

Por razones diversas he tenido que buscar una forma de modificar la definición de un Bean en Spring, de tal manera que una propiedad fuera modificada según un valor que fuera cargado desde el fichero de configuración, en este caso Config.groovy.
El código a continuación ilustra la forma de utilizar BeanFactoryPostProcessor para poder manipular la definición de un Bean durante la carga. Y MutablePropertyValues para poder manipular las propiedades de un Bean.

Código Groovy

import org.springframework.beans.factory.config.BeanFactoryPostProcessor
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
import org.springframework.beans.factory.config.BeanDefinition
import org.springframework.beans.MutablePropertyValues
import org.springframework.beans.PropertyValue
import org.springframework.beans.BeansException
import org.codehaus.groovy.grails.commons.ConfigurationHolder

//Manejo de Cadenas
import org.apache.commons.lang.StringUtils

//Logger
import org.apache.commons.logging.Log
import org.apache.commons.logging.LogFactory

/**
 * Clase que implementa un Post Configurador que nos permite navegar entre todos los
 * Beans y en el caso de encontrar una propiedad "@grails.configuration.alfa" cambiará
 * el valor de esa propiedad por el valor de la variable a partir de la @ y en el caso
 * de no existir esa variable se utilizará como valor la cadena a partir de la @.
 *
 * @author ubaydm
 *
 */
public class GrailsConfigConfigure implements BeanFactoryPostProcessor {
        protected static final Log logger = LogFactory.getLog(GrailsConfigConfigure.class)

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
                                                                     throws BeansException {
logger.info (">> Reconfigurando Beans en la aplicación")
def beansPresentes = beanFactory.getBeanDefinitionNames()
//Ahora cargo por cada Bean por su nombre

beansPresentes.each {
    def beanActual = it
    logger.info (">>> Procesando el Bean $beanActual")
    BeanDefinition beanCargado = (BeanDefinition)beanFactory.getBeanDefinition (beanActual)

    MutablePropertyValues mutablePropertys = beanCargado.getPropertyValues()
    //En caso de que el Bean no tenga propiedades no se procesa
    if (mutablePropertys.size() > 0) {
           //Obtención de la propiedades
           PropertyValue[] propiedades = mutablePropertys.getPropertyValues()
           propiedades.each { propiedad ->
              def namePropiedad = propiedad.getName ()
              logger.info (">>>> Procesando la propiedad $namePropiedad")
              def valorActual = propiedad.getValue ()

              if (valorActual.contains('@')) {

                  def valorParaCambio = StringUtils.substringAfter (valorActual, "@")
                  def valorNuevo = valorConfiguracion (valorParaCambio)

                  logger.info (">>>>> Cambiando la propiedad $namePropiedad por $valorNuevo")
                  PropertyValue propiedad = mutablePropertys.getPropertyValue(namePropiedad)

                  PropertyValue nuevaPropiedad = new PropertyValue (address, valorNuevo)
                  mutablePropertys.setPropertyValueAt(nuevoAddress, 0)
              }
           }
    }
}

}
}

Definición de Bean

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:cxf="http://cxf.apache.org/core"
      xmlns:jaxws="http://cxf.apache.org/jaxws"
      xmlns:util="http://www.springframework.org/schema/util"
      xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.0.xsd">

<bean class="GrailsConfigConfigure"/>

    <jaxws:endpoint id="beanAModificarId"
    				implementorClass="BeanModificado"
                                implementor="#beanModificado"
propiedad="@propiedad.en.config">
</jaxws:endpoint>

</beans>

Enlaces de Referencia:

• BeanFactoryPostProcessor
• MutablePropertyValues

En estos días he tenido que buscar una forma de detectar si un Nif español era o no válido para lo que me he ayudado de la Wikipedia. Y a continuación expongo lo que he hecho.

Función para detectar Nif correcto.

def nifValido (nif) {
  if (nif == "")
          return false
  def n = nif.toUpperCase()
  String NIF_STRING_ASOCIATION = "TRWAGMYFPDXBNJZSQVHLCKET"
  def dni = n[0..-2].toInteger()
  if ((n ==~ /^[0-9]{8}[A-Za-z]$/) && (n.contains(NIF_STRING_ASOCIATION.charAt(dni % 23).toString()))){
           log.info ("El nif $n es correcto")
           return true
  }
  log.info ("El nif $n No es correcto")
  return false
}

Enlaces de Referencia

• Número de Indentificación fiscal (Nif) , referencia la Wikipedia.
• Algoritmo para obtener la letra del NIF, referencia la Wikipedia.

Por diferentes razones he tenido que manipular el tipo XMLGregorianCalendar. Y a continuación pongo todo lo que he aprendido.

Date to XMLGregorianCalendar

import javax.xml.datatype.DatatypeFactory
def calendar = new GregorianCalendar()
calendar.setTime ( new Date ())
def alfa  = DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar)

println "Tipo Final ${alfa.class.name}"

Salida

Tipo Final com.sun.org.apacha.xerces.internal.jaxp.datatype.XMLGregorianCalendarImpl

Por diferentes razones he tenido que manipular el tipo XMLGregorianCalendar. Y a continuación pongo todo lo que he aprendido.

XMLGregorianCalendar to Date

import javax.xml.datatype.DatatypeFactory
def calendar = new GregorianCalendar()
calendar.setTime ( new Date ())
def alfa  = DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar)

println "Tipo final ${alfa.toGregorianCalendar().getTime().class.name}"

Salida

tipo final java.util.Date