Compilar un JRXML (jasperReports) desde el cliente java.

Este fix se hizo por la necesidad de no cambiar toda la aplicación Java y usar la librerías que ya estaban presentes en el cliente  (JARs) 

JasperReport jasperReport = JasperCompileManager.compileReport(System.getProperty("user.dir") + "\\ArchivoACompilar.jrxml");

JRSaver.saveObject(jasperReport, System.getProperty("user.dir") + "\\ArchivoCompilado.jasper");

Con esas dos instrucciones se puede hacer modificaciones de un reporte .jrxml y compilarlo en la versión que tengas en el proyecto en los Jars que se tengan y no hay necesidad de actualizar  todas las librerías para que la nueva versión de JasperReports pueda funcionar en tu aplicación 

Java: Usar un jProgressbar Indeterminada. (setIndeterminate)

 En Java para usar un jProgressbar es necesario el uso de threads (o al menos yo no los he podido manipular sin threads).

Al hacer un aplicación, por lo general los usuario al no ver elementos informativos en la interfaz suelen reportar que no funciona o que va lenta, con este jProgressbar indeterminado lo que haces es darle al sensación al usuario que se esta llevan a cabo los proceso necesarios para la acción que requiere.

En mi caso, mi aplicación debe conectarse a una bd y validar usuario, entonces para poder mostrar la información en el jProgressbar hago lo siguiente.

En el botón que utilizo para hacer la verificación hice lo siguiente. 

En le botón que inicia mi hilo*******************************

 Thread hiloPB= new Thread("el hilo") {
            public void run() {
                verificar();
            }
        };
        hiloPB.start();

******************************************************

Aquí mi función de verificación **************************** 

 private void verificar() {

        /* Aquí se activa la animación indeterminada   */

        jp.setIndeterminate(true); 

/* El código necesario aqui*/

      /* Aquí se desactiva la animación indeterminada   */

       jp.setIndeterminate(false);

*****************************************************

Con eso pude solucionar el uso del jProgressbar 

Copiar archivos a la carpeta dist para empaquetado de jars

 para copiar archivos y carpetas al build de java para el "empaquetado" o mejor dicho para el uso de la carpeta dist

Dentro del build.xml hay que ingresar estas líneas de xml para que al dar build en el IDE en mi caso NetBeans pueda copiar archivos necesarios para la ejecución de tu programa 

<copy file="conf" todir="${dist.dir}"/>  <!--copia de archivos-->

<copydir src="../tuProyecto/reportes/"<!--Copia de Carpetas->

           dest="${dist.dir}/reportes"

/>

Proxmox: Montar un disco.

Revisar cuantos disco duros tiene tu server disponibles:

fdisk -l

obtendremos una salida parecida a la siguiente donde están los discos listados.

Disk /dev/sdb: 931.5 GiB, 1000204886016 bytes, 1953525168 sectors
Units: sectors of 1 * 512 = 512 bytes
Disk /dev/sda: 931.5 GiB, 1000204886016 bytes, 1953525168 sectors
Units: sectors of 1 * 512 = 512 bytes
Device       Start        End    Sectors  Size Type
/dev/sda1       34       2047       2014 1007K BIOS boot
/dev/sda2     2048    1050623    1048576  512M EFI System
/dev/sda3  1050624 1953525134 1952474511  931G Linux LVM 

/dev/sdb suele ser el secundario y en /dev/sda es donde suele estar montando el sistema operativo (linux) y se pude ver por las particiones sda1,2y3

Estando seguro de que partición es la maestra y cual sera nuestra esclava procedemos a darle formato para poder ser utilizada:

cfdisk /dev/sdb

Seguiremos los comando de Nuevo -> Tamaño -> y tipo de partición "Primary"

Teniendo la nueva partición hay que darle formato:

mkfs.ext3 /dev/sdb

Terminado el proceso de formato seguimos con el de montar la nueva unidad  primero creando una carpeta para ahí montar nuestro nuevo disco esclavo

mkdir /disk2
mount -t ext3 /dev/sdb /disk2

Ahora editaríamos el fstab para montar la partición iniciando el sistema siempre

nano /etc/fstab
y dentro del archivo
/dev/sdb1 /disk2 ext3 defaults,errors=remount-ro 0 1

Terminado el proceso de creación, formateo y montaje del disco esclavo ahora procedemos a darlo de alto en proxmox como un disco duro para uso libre.

Dentro de proxmox datacenter > storage > select "add" ->Directory
ID: el nombre como quieres reconocer el disco duro.
Directory: poner el directorio donde montamos el disco en mi caso /disk2 con el /
Content: El tipo de contenido que vas a guardar. 

Con eso tenderemos el disco esclavo del server al servicio de todo el datacenter.

Comando para ver la versión de linux que estamos utilizando:

uname -a

hostnamectl

Tener y elegir entre varias versiones de Java en linux

Primero instalar versión nueva de java

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


Al instalar la versión nueva de java, hay que revisar cuantas más tenemos instaladas, para eso utilizamos el comando  update-java-alternatives --list como superusuario

xxyyxy:~$ sudo update-java-alternatives --list
java-7-oracle 1        /usr/lib/jvm/java-7-oracle
java-8-oracle 1081  /usr/lib/jvm/java-8-oracle


Teniendo la lista que nos marca las versiones de java correctamente instaladas pasamos al cambio:

Con el comando como superusuario  update-alternatives --config java   podemos cambiar la version de ejecución de java en una lista


xxyyxy:~$ sudo update-alternatives --config java
Existen 3 opciones para la alternativa java (que provee /usr/bin/java).

  Selección   Ruta                                     Prioridad  Estado
------------------------------------------------------------
   0            /usr/lib/jvm/java-8-oracle/jre/bin/java   1081      modo automático
* 1            /usr/lib/jvm/java-7-oracle/jre/bin/java   1         modo manual
   2            /usr/lib/jvm/java-8-oracle/bin/java       1         modo manual
   3            /usr/lib/jvm/java-8-oracle/jre/bin/java   1081      modo manual

Pulse <Intro> para mantener el valor por omisión [*] o pulse un número de selección:


Y con el comando update-alternatives --config javac  podemos cambiar la versión de compilado de java.

xxyyxy:~$ sudo update-alternatives --config javac
Existen 2 opciones para la alternativa javac (que provee /usr/bin/javac).

  Selección   Ruta                                  Prioridad  Estado
------------------------------------------------------------
  0            /usr/lib/jvm/java-8-oracle/bin/javac   1081      modo automático
* 1            /usr/lib/jvm/java-7-oracle/bin/javac   1         modo manual
  2            /usr/lib/jvm/java-8-oracle/bin/javac   1081      modo manual

Pulse <Intro> para mantener el valor por omisión [*] o pulse un número de selección:


Este comando me ayuda de momento dado que estoy llevando a cabo un migracion de runtime 7 a 8

Obtener Timestamp (java)

Formatear primero la fecha de la manera en la que se trabaja en el sistema

SimpleDateFormat dateFormat = new SimpleDateFormat("d/M/yyyy");

Seguido se debe de obtener la fecha (en mi caso de un textBox)

Date fecha = dateFormat.parse(tfFecha.getText());

Y al final se obtiene de esta fecha el fastTime

String tsFecha = String.valueOf(fecha.getTime());

getTime retorna un long por si lo quieres poner en una variable numérica, el Int no sera suficiente.

Así de 29/1/2018 obtenemos 1517205600000

Capturar ApiProxy$OverQuotaException en proyecto jsp

Saludos a todos. esta es mi primera entrada del 2017 ya después de mucho tiempo si publicar. 

Este código guía funciona para poder manejar de manera correcta el error en Google App Engine (GAE) al sobrepasar la cuota de envíos de emails, esto en una proyecto java usando jsp.

importar: com.google.apphosting.api.ApiProxy.OverQuotaException;

la excepción se captura al enviar el email:

try {

       mailService.send(msg);

}catch (OverQuotaException ex) {

       //HttpServletResponse resp"

       resp.sendRedirect("/jsp/OverQuotaException.jsp"); 

}

Esta función captura el error del servidor "ApiProxy.OverQuotaException" y maneja la excepción de manera idónea y se hace una re-dirección hacia una pagina jsp para poder avisar al usuario del problema y así no mostrar una pagina genérica de error.

Evitar web crawlers en Koha (CPU 100%)

Soy administrador (sysadmin) de varios sistemas en GC (Google Clould) y uno de los sistemas que administro es una instancia de Koha (Sistema integral de gestión bibliotecaria) en una plataforma GCE (Google Compute Engine).

Al monitorizar el sistema Koha, el uso del CPU de la instancia estaba siempre al 100% de su capacidad, lo cual causaba molestia a los usuarios  debido a que el sistema estaba demasiado lento.

Al revisar las causas, encontré que esto se debe a web crawlers los cuales  hacen búsquedas en el catálogo de Koha para poder indexar resultados, la búsqueda de soluciones me llevo a este wiki de Koha para poder realizarle un tuning (afinamiento) al sistema.

https://wiki.koha-community.org/wiki/Koha_Tuning_Guide


Esta guía ayudo a muchos, pero en mi caso no, los web crawlers seguian accediendo a pesar de agregar el archivo " robots.txt ".

La forma de solucionarlo fue creando (en mi caso) el archivo .htaccess con este archivo de configuraron del servidor Apache  logre detener los web crawlers el uso de este archivo de configuración, puede traer repercusiones a tu servidor, en el caso de eficiencia y tiempo de espera, pero para una instancia pequeña como la que administro es perfecta.

Usando esta lista:

http://www.robotstxt.org/db.html

y este generador de archivo .htaccess en esta página http://incredibill.me/htaccess-block-user-agent

ya con el archivo creado, simplemente resto ponerlo en la carpeta www de apache y reiniciar el servidor, con esto se arreglo el problema de los web crawlers que alentaban el procesador y las búsquedas en mi instancia de Koha.

Espero que esta información les sea de ayuda a quien logre encontrar esta entrada.

Escribir un archivo en Java,

public void archivoSalida(String texto) throws IOException {
        String ruta = "hola.txt";
        File archivo = new File(ruta);
        BufferedWriter bw;
        if(archivo.exists()) {
            bw = new BufferedWriter(new FileWriter(archivo, true));
            bw.write(texto);
        } else {
            bw = new BufferedWriter(new FileWriter(archivo));
            bw.write(texto);
        }
        bw.close();
    }

Este método recibe un String para poder escribirlo en un archivo, sí el archivo existe lo abre y escribe, no borra el contenido del archivo solo escribe la final, esto se logra con el segundo parámetro del constructor del FileWrite al cual se le envía TRUE para escribir y FALSE para sobrescribir 

sí el archivo no existe lo crea y escribe en el.

VBox: Kernel driver not installed (rc=-1908)

En linux me dio la casualidad que queria correre una maquina virtual en VBox y resulto el siguiente error

"The VirtualBox Linux kernel driver (vboxdrv) is either not loaded or there is a permission problem with /dev/vboxdrv. Please reinstall the kernel module by executing
'/etc/init.d/vboxdrv setup'
as root. If it is available in your distribution, you should install the DKMS package first. This package keeps track of Linux kernel changes and recompiles the vboxdrv kernel module if necessary."

Bueno lo que leei  que se usa para arreglarlo, es desintalar el viejo VBox e instlarlo de nuevo

sudo apt-get install linux-headers-generic build-essential dkms
sudo apt-get remove virtualbox-dkms
sudo apt-get install virtualbox-dkms

Vaciar papelera por completo en Linux

Para que este blog no se oxide, aquí el comando que utilice para vaciar la papelera con un archivo que no se dejaba borrar.

$ sudo rm -rf ~/.local/share/Trash/files/*

Evitar que el SSH hacia instancia GCE se rompa.

Feliz 2016 a todos =)

En mi experiencia con GCE (Google Compute Engine) he tenido la mala fortuna que al realizar una tarea larga como un "dd" para hacer el respaldo del disco duro o al comprimir el imagen que crear el "dd" el SSH después de un rato de inactividad me marca:

Write failed: Broken pipe
ERROR: (gcloud.compute.ssh) [/usr/local/bin/ssh] exited with return code [255].

Bueno lo que he estado utilizando y me ha ayudado no solo a evitar el broken pipe si no también para poder darme cuenta de lo que hace la maquina es utilizar:

pv es un comando con el cual podemos añadir una barra de progreso a esos comandos que no cuentan con un modificador o bandera para activar la barra de progreso.

1.- Para usarlo es necesario instalarlo si no se tiene

$ sudo apt-get install pv

 2.- Para usar pv con dd se utiliza el siguiente comando

$ sudo dd if=/dev/disk/by-id/google-temp |pv|sudo dd of=/mnt/tmp/disc.img bs=5M

3.- Para utlizar pv con pigz 

$ pv -tpreb /archivo/a/comprimir | pigz -k --best > comprimido.gz

 
 Con eso obtendrás una barra de progreso similar a esta

17.4GB 0:11:28 [35.5MB/s] [====>                                                  ]  7% ETA 2:25:52

 Con esto evité el broken pipe.

Manejo de excepciones en jsp

Primero debemos saber bien que es una excepción y su manejo y para ello aqui esta este link de wikipedia

https://es.wikipedia.org/wiki/Manejo_de_excepciones

Ahora ya que recordamos o conocemos que es una excepción procedemos  a su manejo en tiempo de ejecución en una aplicación web con jsp.

En mi caso se ha creado una excepción que controla si un usuario esta esta loggeado o no.
-----------------------------------------------------------------------------------
public class ErrorLoggeo extends Exception {
    public ErrorLoggeo(String e) {
        super(e);
    }
} 
-----------------------------------------------------------------------------------

Ahora iremos al scriptlet que controla el jsp para manejar esa excepción:
-------------------------------------------------------------------------------------------------------------
public static queryUser(String id_usuario) throws ErrorLoggeo { 
...

if (userService.getCurrentUser() == null){
            throw new ErrorLoggeo("Usuario no registrado");
        }
...
}
--------------------------------------------------------------------------------------------------------------

Ahora en tu archivo jsp, vamos a cachar esta excepción que creamos y la redirigimos a una pagina de error la cual sirve para advertir el error  y ejecutar la acción prudente para manejarlo.
-------------------------------------------------------------------------------------------------------------------------
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<!DOCTYPE html>
<html>
    <%
        String id_usuario = request.getParameter("id");
        String usuario = null;
        try{
        usuario = queryUser(id_usuario);
        }catch(ErrorLoggeo e){
           String redirectURL = "/jsp/error.jsp";
           response.sendRedirect(redirectURL);
        }
    %>
    <head>
        <link rel="...
--------------------------------------------------------------------------------------------------------------------------

Con esto pasos ya solo debemos hacer las correcciones pertinentes en la pagina de error para así controlar correctamente este tipo de errores.

Hay otras formas de controlar las excepciones desde el web.xml pero ya lo pondré en otra entrada.

Por cierto Guillermo L. R. autor de este blog, les desea felices Fiestas.

Otra forma de respaldar VM de GCE a dispositivo local

Esta forma es muy parecida a la anteriormente publicada, solo cambia en algunos puntos, pero a mi parecer esta forma es mas controlada y te da mas seguridad de que se esta respaldando todo el disco duro.


1.- Crear un disco duro del doble de capacidad del que se quiere respaldar, esto con la finalidad de poder guardar la imagen del disco duro a respaldar de manera holgada en el disco duro nuevo creado.

2.- Cuando se tenga el nuevo disco duro hay que entrar a la instancia de GCE para montar el nuevo disco en nuestro SO.

Revisar que discos duros se encuentran disponibles

$ ls -l /dev/disk/by-id/google-*

Hacer la carpeta donde se va a montar el nuevo disco duro

$ sudo mkdir /mnt/tmp

Montar el disco duro donde se guardara el respaldo

$ sudo /usr/share/google/safe_format_and_mount -m "mkfs.ext4 -F" /dev/sdb /mnt/tmp

3.- Ahora lo que se hace es una copia entera del nuestro disco duro al nuevo montado

$ dd if=/dev/disk/by-id/[Nuestro disco duro a copiar] of=/mnt/temp/backup/disk.img bs=5M

 4.- El proceso anterior tardara unos minutos (en mi caso fueron 60 min) y ahora solo resta comprimir ese archivo y descargarlo (en la compresión del archivo me llevo 70 min)

Puedes usar pigz para hacer una compresión mas pequeña

5.- Ahora solo descarga el archivo y así tendrás una copia de tu DD mas controlada.

Cambiar el tamaño de disco duro en una VM en GCE

Que tal ya me había tardado en poner una entrada, debería ser mas constante, pero publico aquí cosas que aprendo sobre la marcha de mi trabajo.

Así que el día de hoy me tope con el problema de cambiar el tamaño de un disco duro de una maquina virtual que administro en Google Compute Engine (GCE) y pues después de andar buscando aquí tengo el como hacer el resize de un HD en GCE

Los pasos para hacer le resize del disco duro son los siguientes:

1. Crea un nuevo disco con mas espacio en GCE con la imagen antes creada a la cual quieras incrementar el espacio de disco duro.
2. Crea una nueva instancia de GCE usando para ser creada el nuevo disco el cual ya tiene mas capacidad que el anterior.
3. Ingresa en tu instancia y utiliza el siguiente comando

$ sudo resize2fs /dev/sda1 

Con esto tu parición pasara del almacenamiento pasado al nuevo como se puede ver en la imagen de arriba

Y ya con eso tendrás nuevo espacio disponible, debes recordar que si incrementas el espacio del disco o de otro componente en GCE puede venir un cargo extra en la factura.

Información vía : stackoverflow

Exportar instance (VM) de Google Compute engine para resguardo local (LINUX VM)

Para hacer un respaldo de la VM de GCE debes de hacer lo siguientes:

1.- Crear un nuevo disco temporal este debe ser una copia del disco actual que estas utilizando, para esto debes de hacer un "snapshot" de tu disco y con ese crear el nuevo.

 

2.-Debes de ejecutar el comando attach-disk desde tu maquina local para poder vincular el disco creador a tu sistema operativo, esto se logra con el siguiente comando:

$ gcloud compute instances attach-disk  [tu instancia]  --disk temp  \--device-name  temporary-disk  \--zone  [zona de tu proyecto]   

4.-Con el proceso anterior finalizado, ingresa por SSH a tu VM y revisa que el vinculo de tu Disco duro temporal se haya realizado y se encuentre montado en tu sistema operativo. para eso deberás listar los discos duros de tu SO con el siguiente comando:

$ ls -l /dev/disk/by-id/google-*

tendrás un salida similar a la siguiente:

$ ls -l /dev/disk/by-id/google-* lrwxrwxrwx 1 root root 9 Jul 29 17:56 /dev/disk/by-id/google-persistent-disk-0 -> ../../sda lrwxrwxrwx 1 root root 10 Jul 29 17:56 /dev/disk/by-id/google-persistent-disk-0-part1 -> ../../sda1 lrwxrwxrwx 1 root root 9 Aug 25 18:16 /dev/disk/by-id/google-temporal-disk -> ../../sdb # El disco temporal reside en: /dev/sdb

5.-Se crea un carpeta temporal, este paso es importante recuerda la ruta:

$ sudo mkdir /mnt/tmp

6.-Monta el nuevo disco:

$ sudo /usr/share/google/safe_format_and_mount -m "mkfs.ext4 -F" /dev/sdb /mnt/tmp

7.-Este paso es el mas importante, con el comando "gcimagebundle" se creará un archivo .tar del disco duro montado, y lo pondrá en la carpeta temporal que se creo antes, por eso es importante crear el disco duro temporal con las imagen del disco a resguardar.

$ sudo gcimagebundle \-d /dev/sda -o /mnt/tmp/ --log_file=/tmp/abc.log

nota: el tiempo de ejecución de este proceso, dependerá del tamaño de tu disco y del tipo de VM que estés utilizando.

8.-Cuando el proceso termine, busca un archivo con un nombre conformado de un gran cadena de números hexadecimales  con extensión .tar.gz

/mnt/tmp/HEX-NUMERO.image.tar.gz

9.-Por ultimo copia ese archivo a tu maquina local con el comando de copia que puse anteriormente (Copiar archivos de pc local a VM en Google Compute Engine) y respalda el archivo de la manera que mas te agrade, en mi caso son  dvds

Krita, la alternativa, de la alternativa.

Krita, es un software de edición, pintura e ilustración digital distribuido bajo la licencia GNU GLP.

Las característica de Krita son orientadas a la creación de dibujo digital, mas que las funciones de edición de fotográfica, sin embargo soporta funciones de edición de mapa de bits e ilustración vectorial.

La popularidad de Krita va en aumento llegando al punto que el departamento de Arte y Tecnología de la Imagen (ATI) de la Universidad de París sustituyo el uso de Photoshop por el de Krita (https://krita.org/item/goodbye-photoshop-and-hello-krita-at-university-paris-8/)

Lo restante por mencionar seria que le des una oportunidad a Krita y tu decidas si es la alternativa que estabas buscando. 

Descarga Aquí 

Copiar archivos de pc local a VM en Google Compute Engine

Si tienes una VM en GCE (Google Compute Engine) y necesitas copiar archivos de tu VM a tu pc local o quieres enviar archivos de tu pc local a tu VM hay un comando que te puede  funcionar

Los ejemplos que se mostraran son en PC con Linux a un VM con Linux (Sí, trabajo con Linux...)

PC a VM

gcloud compute copy-files [/archivo/a/copiar] [Nombre de tu VM]:[/directorio/destino] --zone "[la zona donde reside tu VM]"

VM a PC

gcloud compute copy-files [Nombre de tu VM ]:[/archivo/a/copiar] --zone "[la zona donde reside tu VM]" [/directorio/destino]

Importante:

Para hacer la copia de archivos debes de estar "logueado" en gcloud

gcloud auth loggin  

y tener seleccionado el proyecto donde se encuentra tu VM

gcloud config set [projectnombre-de-tú-proyecto] 

 

para mas información consulte https://cloud.google.com/sdk/gcloud/reference/compute/copy-files

Conectar Google Cloud SQL a un Cliente MySQL

Antes que anda debes de tener una cuenta de Google (gmail) y activar tus 60 días gratis de prueba dentro de:

https://console.developers.google.com

Con tu cuenta gratis podrás acceder  durante 60 días a casi todos los componente de Google Cloud Platform.(No tendrás acceso a componente premium).

Aquí comienza tu travesía para lograr conectar Cloud SQL en la nube a tu maquina a tú lado.

1.- crea un "Instancia" de Cloud SQL recuerda usar nombres con minúsculas, sin caracteres especiales y separados por ' - ' (no emoticon)

2.-Accede a tu instancia creada para ver las opciones que ofrece CloudSQL

3.-Dentro de "Base de datos" podrás crear tu BD que después podrás manipular con un cliente de MySQL

4.-Ahora en control de acceso crea un usuario el cual podrá acceder desde el cliente. 

5.- Ahora debes autorizar la aplicaciones o IPs las cuales tendrán acceso a tu base de datos. esto es parte de la seguridad de Google  la cual puedes amar u odiar (en mi caso la odie un poquito).

• Redes permitidas: son rangos de IPs o IPs que sabes que tendrán acceso a tu base de datos para el caso de este ejemplo debes de usar la ip que tienes asignada  para saberla entra a la pagina https://www.whatismyip.com/es/ y así podrás garantizar el acceso de tu cliente local.

 

• Aplicaciones de App Engine: aquí podrás dar acceso a las aplicación de que tengas hospedadas en App Engine y que deban de utilizar una base de datos

6.- Obtener un IPv4, Cloud SQL otorga por default una IPv6 para poder conectar o manipular la base de datos es mas fácil utilizar un IPv4, lo lamentable es que para obtener un IPv4 Cloud SQL te la otorgara con un costo de 0.01 cents por cada hora que no se use !! para este ejemplo y como tenemos nuestra prueba gratis utilizaremos la IPv4

7.- Ya con usuario y control de accesos es momento de conectar el cliente a la nube, para este ejemplo utilizare el cliente de MySQL Workbench.

8.- Ya instalado Mysql WorkBench procedemos a la conexión llenamos todos los campos necesarios en el cliente para conectarnos y hacemos el teste de conexión

 9.- Hacemos la conexión

10.- Ahora si tendremos  acceso a nuestra base de datos en la nube gracias a Cloud SQL y a Mysql WorkBench