Estadísticas para repositorios GIT

Tags: , , ,

Git es un repositorio de datos que esta ganándole mucho terreno a SVN, existe una comunidad (GIT HUB) donde se podrán encontrar muchos proyectos en Git para practicar lo que vamos hablar a continuación.

Para descargar un proyecto solo debes clonarlo de la siguiente manera.

git clone git://github.com/jquery/jquery.git

Gitstats

Gitstats es un proyecto de Heikki Hokkanen que podrás encontrar en http://gitstats.sourceforge.net/ , este proyecto esta desarrollado en Python y es muy sencillo de usar, necesitas tener instalado Git y Gnuplot para poder generar los gráficos como el de abajo.

Para generar las estadisticas solo debes ejecutar lo siguiente:

./gitstats /pathToGitRepo/ pathToGenerateHTMLStats/

Gitstat

Un proyecto parecido al anterior, pero en este caso es algo diferente, esta desarrollado en PHP y Perl y lo puedes encontrar en http://sourceforge.net/projects/gitstat/, solo debes crear una base de datos y preparar el archivo de configuracion config.pl que luego deberás poner en un Cron para que el actualice periódicamente las estadísticas, el almacena los cambios en la base de datos. Lo curioso de este proyectos es que esta alojado en un repositorio CVS, como dice el refran, en casa de herrero, cuchillo de palo.

Cómo crear el schema de la base datos con Anotaciones de Hibernate y Spring

Tags: , , , ,

A veces es necesario hacer cambios a nuestra base de datos, y siempre estaremos lidiando con las herramientas gráficas o desde la consola, con los cambios en la base de datos, pero existen formas de hacer este trabajo “sucio” mucho más rapido y ahorrando tiempo.

En nuestro caso, usaremos Spring 2.5 y Hibernate 3.3 y MySQL, donde es necesario ya tengas armado los beans de conexión a la base de datos. El siguiente código es un array de cadenas, si en nuestro caso tenemos segmentado los xml de spring, los añadiremos de la siguiente manera.

// array de string para agregar todos tus archivos de configuración de spring
private static final String[] SPRING_CONFIG_FILES =
new String[]{"source/spring/config/xxxxxx-db-context.xml", "source/spring/config/xxxxxxx-param-context.xml"};

A continuación, el código necesario para generar nuestra base de datos, el FileSystemXmlApplicationContext carga el Contexto de la Aplicación, y una vez teniendo el contexto obtenemos el SessionFactory, que en nuestro caso usamos Anotaciones, creamos el bean en base a la clase AnnotationSessionFactoryBean , esto es importante pues en base a esta clase usaremos los metodos dropDatabaseSchema(); para borrar el actual schema (tablas, relaciones , etc) y luego ejecutamos createDatabaseSchema(); para crear el nuevo schema.

// carga el application context de Spring
 FileSystemXmlApplicationContext appContext = new FileSystemXmlApplicationContext(SPRING_CONFIG_FILES);
// Obtiene el bean del session factory
 AnnotationSessionFactoryBean annotationSF = (AnnotationSessionFactoryBean)  appContext.getBean("&sessionFactory");
// si quieres eliminar el schema de la base de datos
 annotationSF.dropDatabaseSchema();
// para crear nuevamente el schema de la base de datos
 annotationSF.createDatabaseSchema();

Los archivos de configuración de Spring, deben lucir de la siguiente manera, hay que destacar el hibernate.dialect donde indicamos el dialecto que usaremos para crear el schema, en el caso de MySQL puede ser MySAM o InnoDB, luego el parametro hibernate.hbm2ddl.delimiter que también indicamos el tipo de tablas que usaremos en mi caso usaré type=InnoDB.

<bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${datasource.classname}" />
        <property name="url" value="${datasource.urldb}" />
        <property name="username" value="${datasource.userbd}" />
        <property name="password" value="${datasource.pass}" />
    </bean>
 
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
          <list>
              <value>Clase1</value>
              <value>Clase2</value>
          </list>
        </property>
        <property name="hibernateProperties">
           <props>
                <!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                <prop key="hibernate.dialect">${datasource.dialect}
                </prop>
                <prop key="hibernate.show_sql">${datasource.showsql}</prop>
                <prop key="hibernate.hbm2ddl.delimiter">${datasource.delimited}</prop>
            </props>
        </property>
      </bean>

Lo Nuevo de Spring 3.0 RC1

Tags: , ,

springsource

Hace poco el equipo de Spring Source liberó Spring 3.0 RC1 y viene con muchas nuevas características interesantes, para mi una de las mas interesantes es que ya viene con soporte para Java 6 y completamente basado en Java 5, ya era hora !. Me tomado el permiso de pegar la traducción que hizo Dos Ideas.

  • Completamente basado en Java 5. Esta la primer versión de Spring que necesita Java 5 o superior para funcionar, y que utiliza la sintáxis de Java 5 en todo el API de Spring, y también en su implementación. Por ejemplo, el API del BeanFactory retorna instancias tipadas con generics cuando es posible, y un ApplicationListener puede declarar tipos de eventos específicos con generics. En comparación, Spring 2.5 (la versión actual de Spring) todavía es compatible con el JDK 1.4, aunque mucha funcionalidad de alto nivel se construía en Java 5.
  • Lenguaje de expresiones de Spring (SpEL – Spring Expression Language). Un parser de expresiones para usar en la definición de los beans, que permite referenciar a estructuras anidadas (por ejemplo, propiedades de otros beans), y también a estructuras del sistema (por ejemplo, variables de entorno) usando la sintáxis común #{…} en el valor de las propiedaes de un bean. Esto también sirve como base para otras características basadas en expresiones en otros proyectos de Spring.
  • Soporte extendido para componentes basados en anotaciones. Se incluye el concepto de clases de configuración y métodos de factory anotados – ¡las características fundamentales del proyecto Spring JavaConfig finalmente están disponibles en Spring!. Sprint también permite inyectar valores de configuración a través de expresiones @Value, y referirse a valores de la configuración usando expresiones dinámicas #{…} o estáticas ${…}.
  • Modelo de estereotipos. Permite crear anotaciones “de atajo” a través del uso de meta-anotaciones. Por ejemplo, para determinar scopes predeterminados o características de transacción predeterminadas en estereotipos propios. Imaginen una anotación propia @MiServicio que indica @Service, @Scope(“request”) y @Transactional(readOnly=true) usando una única anotación. Este es el principio de No Repetirse aplicado al uso de anotaciones de componentes.
  • Anotaciones de inyección de dependencias estándar. Spring 3.0 provee un soporte inicial para el JSR-330 specification for Dependency Injection in Java- inyección a través de anotaciones usando javax.inject.Inject y sus calificadores asociados y modelo de proveedores, como una forma alternativa a la anotación @Autowired propia de Spring. Tengan en cuenta que el JSR-330 todavía no está terminado; el soporte para javax.inject en Spring se irá completando a medida que madure la especificación.
  • Modelo de validaciones declarativo basado en anotaciones de restricciones. Configuración al estilo de Spring de un proveedor de JSR-303 Bean Validation (como ser, Hibernate Validator 4.0). Spring 3.0 viene con una opción para hacer validaciones basadas en anotaciones en Spring MVC, exponiendo una vista unificada cuando no se cumplen las restricciones. Tengan en cuenta que el JSR-303 está próximo a terminarse, aunque todavía puede tener modificaciones.
  • Soporte para REST extendido. Soporte nativo para REST en Spring MVC, como ser mapeos de peticiones REST, extracción de variables URI a través de parámetros @PathVariable, y resolución de vistas guiadas por la negociación del contenido. Imaginen Spring MVC 2.5 con soporte de primera clase para REST – y manteniendo en enfoque de MVC. Hay soporte para el lado del cliente de REST a través de la clase RestTemplate.
  • Mapeo Objeto/XML (OXM). Tal como se usaba en Spring Web Services, ahora dentro del núcleo de Spring Framework. Abstracciones para el marshalling y unmarshalling con soporte directo para JAXB 2, Castor, etc. Se provee opciones de integración para soporte de contenidos XML en Spring MVC y Spring JMS.
  • Soporte para Portlet 2.0. Spring MVC soporta completamente los entorno de Portlet 2.0 y el nuevo modelo de recursos y eventos de Portlet 2.0. Se incluyen facilidades de mapeo para peticiones de portlet típicas: @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping.
  • Nuevo sistema de scheduling. Nuevos mecanismos de TaskScheduler y Trigger con soporte estilo cron, alineados con el mecanismo de Spring TaskExecutor. Spring 3.0 provee un namespace que soporta anotaciones @Async y @Scheduled. Esto se puede ejecutar sobre pooles nativos de hilos o en pooles manejados por Servidores de Aplicaciones, incluyendo soporte para los servidores de aplicaciones Java EE más populares.
  • Y por último, soporte inicial para Java EE 6. Spring 3.0 soporte el uso de JSF 2.0 y JPA 2.0 dentro de Spring, junto al soporte de JSR-303 y JSR-330. Se irá incluyendo soporte para otras tecnologías de Java EE 6 (como Servlet 3.0) a medida que se vayan concretando los productos.

Bridge en VirtualBox para tus máquinas virtuales

Tags: , , , , , ,

virtualbox-logoSi no conoces que es  Virtual Box es la versión libre para virtualizar máquinas (Virtualización GPL).

Pero que es Virtualizar?

Virtualizar básicamente es eliminar el hardware de una máquina o servidor y substituirlo por un software que lo emule, de forma que un sistema operativo pueda “hablar” con este hardware simulado o emulado como habla con el hardware real.

Para que me sirve a mi?

Si eres un estudiante o un profesional, las respuestas son muchas, te las resumo aquí.

  • Para probar sistemas operativos, sea Linux o Windows
  • Para emular ambientes bajo control y testeo ( o pruebas)
  • A nivel educativo, si quieres enseñar a alguien a instalar algun SO
  • Solo tienes un Equipo (o Servidor) y necesitas a la fuerza várias máquinas
  • En tu empresa, escasez de equipos y tus usuarios necesitan 2 o más máquinas para su trabajo.

Configurando un Puente

A veces ocurre que queremos tener varias máquinas virtuales en nuestra computadora, sea para emular una pequeña red o porque solo tenemos una tarjeta de red, entonces Virtualbox por defecto nos crea una red privada (NAT), donde tus máquinas virtuales pueden comunicarse entre ellas y acceder a Internet si la maquina que aloja las máquias virtuales tiene acceso a Internet, pero si queremos utilizar nuestra máquina para comunicarnos con todas nuestras máquinas virtuales o conectarnos por SSH en el caso de Linux tendremos que tener una configuración especial, un Bridge o Adaptador PuenteInterface Anfitrión (Simulación de una red real, el Host puede enviar datos al invitado y viceversa, se puede conectar a la red. Se tiene que crear una interface de red virtual en el Host anfitrión por cada tarjeta (interface) de red que use(n) la(s) maquina(s) virtual(es)). Puedes ver una explicación más extensa aquí.

La configuración en VirtualBox instalado en Ubuntu es así …

virtualLinux

Y Para la configuración de VirtualBox en  Windows, es similar la siguiente.

virtualWindows

© 2009 JotaDeveloper. Nuestros contenidos están bajo licencia Creative Commons mientras no se indique lo contrario,
y pueden reproducirse libremente sin más que mencionar la fuente ("JotaDeveloper") y la URL concreta del artículo original. .

This blog is powered by Wordpress and JotaDeveloperTheme.