Enviar un correo mediante BATCH

Algo muy importante hoy en día en el terreno empresarial es el uso de paquetes de líneas de comando o archivos BATCH. Cualquiera puede buscar un manual en internet sobre cómo crear este tipo de Scripts y aprender rápidamente a usarlos. No obstante la cosa se complica cuando nos piden algo tan específico como lo que vamos a ver hoy aquí: Envío de correos.

Si nos repasamos la biblioteca de funciones de la línea de comandos al final daremos con la función mail:to. Es una función interesante cuando queremos que sea el propio usuario el encargado de componer el mensaje y enviarlo, esto es, el usuario tendrá que rellenar los datos que desee del mensaje y darle al botón enviar. Si outlook se encuentra correctamente configurado el email se enviará y habremos acabado. No obstante este es el camino fácil. Vamos a complicarlo un poco. ¿Por qué? Pues porque en esta vida las cosas nunca son tan fáciles.

Con el método anterior es necesaria la presencia del usuario para un envío correcto del correo. Pero qué pasa si nos encontramos lanzando un script batch y en algún momento se produce un error. Nos gustaría que nos avisase cuanto antes para poder subsanarlo y volver a lanzarlo. No podemos estar delante de la pantalla esperando a que este se produzca para enviar el correo (en tal caso no tendría sentido, ya que nosotros mismos veríamos el error). Por esta razón necesitamos un sistema que permita el envío automático del correo. Sin ayuda del usuario.

Vamos a ver cómo conseguirlo:

1.- En primer lugar necesitamos crear una macro en nuestro outlook que permita el envío de un correo. No hace falta pensar mucho para conseguir esto y si buscamos algo de información en internet, seguro que en seguida la encontramos. No obstante aquí os dejo el código:

Sub EnviarMail()Dim OutApp As ObjectDim OutMail As ObjectDim strbody As String‘ Inicializamos variablesSet OutApp = CreateObject(“Outlook.Application”)OutApp.Session.LogonSet OutMail = OutApp.CreateItem(0)‘ Enviamos el correoOn Error Resume NextWith OutMail.To = “a@a.com“.CC = “”.BCC = “”.Subject = “¡¡Funciona!!”.Body = “Bien bien, ¿quien es tu dios ahora?”.Send.ReadReceiptRequested = TrueEnd WithOn Error GoTo 0‘ Liberación de memoriaSet OutMail = Nothing‘ Dormimos 5 segundos para que se envíe el correoSleep (5000)‘ SalimosOutApp.QuitEnd Sub

2.- Ya tenemos nuestra macro creada en outlook. Ahora es necesario llamarla de alguna manera mediante un script BATCH. Para ello utilizaremos el propio programa de outlook y la función START del prompt. Veamos cómo es esta llamada:

START “” “C:\Archivos de programa\Microsoft Office\Office12\Outlook.exe” /autorun EnviarMail

Bien, pues solucionado. Creamos un batch con esta línea (eso si, cambiando la dirección donde se encuentra outlook instalado en nuestro sistema) y lo lanzamos. Como vemos es necesario incorporar el parámetro: /autorun EnviarMail. Este parámetro indica que queremos abrir outlook lanzando la macro que hemos definido previamente.

Un saludo, ¡hasta otra!

Virus en Pendrives

Buenas a todos:

La mayoría de vosotros utilizáis windows para trabajar normalmente. Todos sabemos (incluso los menos experimentados) que windows sufre una gran lacra: virus, spyware, troyanos, etc. Obviamente lo normal es comprar un buen antivirus que nos tenga el sistema operativo ‘limpio y a pleno rendimiento’ (ja!). Aún así normalmente nuestros pendrives van a parar a otros ordenadores de gente sin ningún cuidado que están repletillos de virus.

La nueva generación de éstos se comunica a través de los pendrives. ¿Cómo funciona? Muy sencillo. El virus o spyware copia normalmente tres archivos en tu pendrive: autorun.inf, un archivo .com .bat o .exe y un archivo .dll. El archivo .com .bat o .exe es el virus en sí, que con la ayuda de la librería .dll explota un fallo de seguridad del sistema operativo para introducirse en él e ir extendiéndose, además de tomar el control de ciertas funcionalidades de tu PC (depende del virus o spyware). Por último el .bat hace que cuando introduzcas el pendrive en tu PC, windows reconozca que es un sistema autoarrancable, esto quiere decir, que cuando introduces el pendrive el archivo autorun.bat llama al virus. ¿Por qué pasa esto? Por que los de Microsoft son gilipollas y se les ocurrió que quedaba muy bien haciendo que si un dispositivo externo (pendrive, CD-Rom, Disco duro externo, etc) llevase un programa, que lo autoarrancase para facilitar la labor del usuario. Esto ha provocado esta oleada de virus.

¿Como evitar que esto nos pase?

Muy sencillo. Primero nos haremos con alguna Live CD con un sistema operativo linux. Por ejemplo con una UBUNTU (http://www.ubuntu.com/getubuntu/download). Arrancaremos nuestro ordenador con la UBUNTU. Una vez dentro introducimos el pendrive. Si lleva ‘bichitos’ nos aparecerán archivos como los comentados antes, con un candado encima del icono y semi-transparentes. Esto lo hace también el virus para que desde windows no puedas verlos y así no borrarlos. En UBUNTU no hay problema porque los virus de windows no le afectan. Este candado indica que se encuentran protegidos. Para desprotegerlos vamos a cada archivo y hacemos:

1. botón derecho en él.
2. Propiedades.
3. Permisos.
4. Lectura y escritura.

Cuando hagamos esto veremos que el archivo deja de tener un candado y ya lo podemos borrar. Cuando tengamos nuestro pendrive limpio, crearemos un archivo llamado autorun.inf. Si, un archivo como el que el virus nos crea. La diferencia es que ese archivo lo vamos a dejar vacío. Una vez lo hayamos creado, entonces toca protegerlo contra escritura. Para ello seguimos los siguientes pasos:

1. botón derecho en él.
2. Propiedades.
3. Permisos.
4. Solo lectura.

¿Qué hemos conseguido con esto? Si introducimos nuestro pendrive en una máquina que no es la nuestra, el virus se copiará al pendrive, pero estará únicamente latente. Al tener el archivo autorun.inf creado y protegido contra escritura no podrá introducir en él el comando de arrancar el virus, por lo tanto se copiará pero cuando introduzcamos nuestro pendrive en el ordenador no se ejecutará.

De vez en cuando revisa tu pendrive con la UBUNTU para borrar los virus.

Salu2 a todos.

Enviar correos con JAVA

Buenos días:
Hoy voy a explicar cómo enviar correos desde java. Para ello he utilizado el entorno de desarrollo Netbeans y el paquete “mail.jar” (se puede encontrar fácilmente por internet).
Para enviar un correo vamos a crearnos una clase llamada Cartero. Esta clase únicamente va a tener un método llamado enviarMensaje. Obviamente al tener una sola clase y no ser ésta un constructor es de suponer que será estática. Esto nos permitirá utilizarla sin necesidad de crear un objeto de la clase cartero. Esta función va a tener los parámetros: destinatario, asunto ymensaje. Veamos cómo queda:

public static boolean enviarMensaje(String destinatario, String asunto, String mensaje) {

Dentro de la función lo primero que tenemos que hacer es establecer una serie de propiedades. Las propiedades se agrupan en pares nombre-valor. Por ejemplo: color-rojo, forma-rectángulo, etc. Para crear un objeto de tipo propiedades utilizamos la clase Properties. Veamos cómo quedan las propiedades que necesitamos y las vamos explicando:

//Creamos las propiedadesProperties props = new Properties();//Servidor de envio smtpprops.setProperty(“mail.smtp.host”, “smtp.gmail.com”);//Autentificación tlsprops.setProperty(“mail.smtp.starttls.enable”, “true”);//Puerto de comunicaciones con el servidorprops.setProperty(“mail.smtp.port”,“587″);//Usuario de la cuenta de correoprops.setProperty(“mail.smtp.user”, “<usuario_correo>@gmail.com”);//Es necesaria la autenticaciónprops.setProperty(“mail.smtp.auth”, “true”);//Contraseña de la cuenta del correoprops.setProperty(“mail.smtp.password”, “<contrasenya>”);

Una vez tenemos todas las propiedades creadas, tenemos que crear un objeto de sesión que se encargará de guardar todas estas propiedades para luego ser utilizadas en el envío del mensaje. Esto se hace de esta manera:

Session sesion = Session.getInstance(props);sesion.setDebug(true); //True o false dependiendo si queremos o no ver lo que pasa

Ya tenemos todo preparado. Ahora nos toca escribir el mensaje que queremos enviar. Para ello utilizaremos una clase llamada MimeMessage. Crearemos un objeto de esta clase con la sesión creada anteriormente. Una vez hecho esto tenemos que introducir quién envía el mensaje, a quién se va a enviar, el asunto y el cuerpo del mensaje. Veamos el código que nos hace esto:

MimeMessage mensaje = new MimeMessage(sesion);mensaje.setFrom(new InternetAddress(“<usuario_correo>@gmail.com”));mensaje.addRecipient(Message.RecipientType.TO, new InternetAddress(destinatario));mensaje.setSubject(asunto);mensaje.setText(cuerpo);

Por último nos resta realizar el envio. Para ello debemos usar la clase Transport. Creamos un objeto de esta clase y realizamos el envío de todos los datos configurados anteriormente. Veamos cómo se hace esto:

try{Transport mta = sesion.getTransport(“smtp”);mta.connect(“smtp.gmail.com”,“<usuario_correo>@gmail.com”,“<contrasenya>”);try{mta.sendMessage(mensaje,mensaje.getAllRecipients());}catch(SendFailedException ex){return false;}mta.close();}catch(Exception ex){System.out.println(“Cartero: Error al enviar “+ex.toString());}}catch(Exception ex){return false;}

Con esto hemos acabado. Si todos los datos introducidos son correctos, el mensaje se enviará y le aparecerá al destinatario en su bandeja de correo.

Salu2 a todos.

Acceso a servidor NTP en JAVA

Buenas tardes lectores:

Hoy vamos a hablar de un tema muy importante cuando estamos desarrollando aplicaciones que van a utilizar servicios de máquinas remotas. Un ejemplo de este escenario lo tenemos en bancos, comercios electrónicos, aplicaciones empresariales distribuidas, etc. Todos estos equipos en cualquier momento van a utilizar un servicio de una máquina remota. Por ejemplo un usuario en españa puede realizar una compra a través de internet en la página de ebay de hongkong. Obviamente la hora local del equipo del usuario no será la misma que la del servidor en hongkong. Otro ejemplo lo podemos ver cuando en una red consultamos la hora de reloj de varias máquinas. Estas consultas nos darán como resultado que ningún reloj posee exactamente la misma hora que otro de la red. Obviamente esto nos debe de llevar a pensar: ¿que va a pasar si cada uno utiliza su propia hora de reloj para realizar las transacciones en un banco? Pues es posible que un cliente pueda sacar dinero de un puesto en el que son las 9:35 y seguidamente vaya a otro puesto en el que son las 9:33 y vuelva a sacar dinero. La segunda transacción aparecería antes de la primera. A simple vista esto no debería de suponer mucho problema, son transacciones de reintegro al fin y al cabo. No obstante si mezclamos transacciones de reintegro, de ingreso y transferencias, la cosa se complica

Veamos ahora una imagen de un ejemplo de escenario para este caso:

Ejemplo de redes privadas con servidor NTP

Como ya os estaréis imaginando, la solución al problema se basa en establecer un reloj maestro para todos los equipos. Este reloj debe de tener una tasa de error muy baja, para evitar los errores lo mejor posible. Cualquier equipo de cualquier red deberá de acceder a este servidor para recoger el valor real de hora y así asignarlo correctamente a cualquier transacción, pedido, modificación, etc. que haga.

Después de esta breve introducción, vamos al turrón.

Como tampo es plan de machacaros, simplemente os voy a dejar una librería hecha en java que, a través de un servidor NTP al que ésta se conecta, obtiene la hora y nos la devuelve.

ntpmessagejava y sntpclientjava

Los archivos se han subido en formato ODT debido a que wordpress no nos deja subir un archivo de código.

Cómo montar un servidor JUDDI en Tomcat

Buenos días otra vez.

Seguimos con la saga de servidores y servicios web. En este caso voy a explicar cómo montar un servidor JUDDI en un servidor tomcat. Las versiones que voy a utilizar son:

• Tomcat 6.x (revísate el post de cómo instalarlo si aún no lo tienes instalado).
• Axis2 (revísate el post de servicios web para averiguar cómo instalarlo y conseguirlo).
• Juddi 2.0rc5 (esto si voy a explicarlo ahora).
• MySQL 5.1 community server (ahora hablamos de esto también).
• MySQL GUI Tools (sigue leyedo…)
• JDBC MySQL connector (más adelante se habla de él).
• JDK 5.0 (importante, con la versión 6.0 no funciona. Descárgalo e instálalo. Cambia las variables de entorno para que apunten en la dirección en la que se encuentre).

Bien, en primer lugar vamos a descargar todo lo necesario. En este caso ya deberíamos de tener descargado, instalado y a punto el servidor tomcat y el axis2 (si no es así, revísate los posts relacionados). Para descargar JUDDI debemos de acceder a la página: http://ws.apache.org/juddi/. En el apartado de ‘Releases’ buscamos la versión 2.0rc5 y descargamos el fichero: juddi-web-2.0rc5.war. Este fichero debemos de copiarlo en la carpeta webapps del directorio de tomcat (llamado también $CATALINA_HOME). Hecho esto arrancamos el servidor tomcat. No va a funcionar aún JUDDI, pero por lo menos nos despliega la aplicación. Una vez se ha arrancado el servidor, lo volvemos a parar. Entramos en la carpeta $CATALINA_HOME/webapps y vemos que nos ha creado una carpeta llamada juddi-web-2.0rc5. Como no es un nombre de carpeta práctico, lo vamos a cambiar por juddi (si, juddi a secas. Practicidad ante todo). Podemos borrar si queremos el archivo juddi-web-2.0rc5.war. Ya no nos hace falta.

En segundo lugar tenemos que instalar el servidor de MySQL 5.1. La forma de instalarlo es diferente dependiendo de si usamos el sistema operativo windows o linux.

Si usamos windows, entramos en la página www.mysql.com y lo descargamos. En la sección de descargas encontraremos la versión 5.1 community server y las GUI Tools. Las descargamos y las instalamos. Procura recordar el usuario administrador que utilizas y su contraseña. Sino luego no podrás acceder. Otro punto importante en la instalación es marcar en la instalación la opción de que la base de datos se instale como servicio del sistema para que automáticamente se arranque en el inicio.

Si usamos linux tendremos que utilizar el apt-get (o synaptics) en caso de versiones compatibles con debian (ubuntu, linux mint, lliurex, etc), rpm en caso de versiones como mandriva, fedora, etc. Descargamos e instalamos el paquete. En principio éste normalmente se instala ya como servicio del sistema, por lo que no habrá que hacerlo. También es importante recordar la contraseña de root. Para la instalación del GUI-tools de MySQL, seguiremos el mismo procedimiento que con el servidor.

Las GUI Tools de MySQL nos van a servir para administrar el servidor de bases de datos MySQL. Ahora veremos para qué es necesario utilizarlo. La instalación de esta aplicación nos crea en el menú de inicio o gnome una entrada a las utilidades de la GUI-Tool. Entre ellas nosotros sólo vamos a utilizar la MySQL-Administrator y MySQL-QueryBrowser.

Bueno, ya lo tenemos todo preparado. El que tenga que ir al aseo que lo haga ya. Luego no quiero interrupciones xD. Vamos a montar el ‘chiringuito’.

Preparación de la base de datos

Lo primero que tenemos que hacer es preparar la base de datos para que aloje la información acerca de los servicios web que se van a dar de alta en el sistema. Obviamente esto no lo podemos averiguar ni sacar de cualquier sitio. Únicamente de la página web de JUDDI. Sin embargo no se han preocupado de incorporar el fichero de configuración de la base de datos como ocurría en las versiones anteriores. ¡NO PASA NADA! Para eso estoy yo, para dejároslo preparado. Descargad el siguiente archivo en PDF. Crear un archivo con la extensión .sql y copiar todo el contenido en él:

>>> create_database

Una vez tenemos el fichero .sql creado abrimos el MySQL-Administrator. Para entrar tendremos que poner como usuario a root y como contraseña la que hayamos establecido cuando instalamos la BBDD. En el cuadro de texto de servidor tenemos que poner localhost (si la base de datos la hemos instalado en el mismo ordenador desde el que vamos a conectar) o la IP del ordenador en la que se encuentra instalada. Dentro de éste nos vamos a la sección ‘Restore’. Desde ésta presionamos el botón ‘Open backup file’. Se nos abrirá un cuadro de diálogo de búsqueda de archivos. Debemos de buscar el archivo .sql que hemos creado anteriormente. Lo seleccionamos y lo abrimos:

Vista del administrador de MySQL

Una vez que se nos ha abierto el fichero tenemos que cargarlo para que cree las estructuras de la Base de Datos que queremos. Para ello debemos de cambiar algunas configuraciones de la ventana que tenemos. Si estamos utilizando windows, debemos de cambiar el ‘Character Set’ a latin1. Si usamos linux, no hace falta. Deberemos dejarlo en utf8. El resto te lo dejo para que lo copies de la siguiente imagen:

Ventana de recuperación de datos

Cuando lo tenemos preparado le damos al botón ‘Start restore’. Si todo ha ido correctamente, te aparecerá una ventana como en la siguiente imagen. Si no ha sido así, investiga porque yo no puedo saber exactamente qué es lo que te ha pasado.

Ventana de aceptación de una recuperación

Una vez hemos hecho esto, ya tenemos la base de datos creada. Si nos vamos a la sección de ‘Catalogs’ podremos ver que se ha creado una base de datos llamada juddi.

Tablas de la base de datos Juddi

¡Estupendo! ya tenemos la base de datos creada. Ahora seguimos con la fiesta. Hay que crear un usuario que pueda tener plenos derechos sobre esta base de datos. Para ello crearemos el usuario juddi. Desde la sección ‘User Administration’ le damos al botón ‘Add New User’. El nombre de usuario será juddi y su contraseña juddi. Veamos en la siguiente imagen cómo ha de quedar este usuario:

Formulario de creación de un usuario MySQL

Una vez tenemos todos los datos rellenos, hacemos click en el botón ‘Apply Changes’. De esta manera el usuario queda registrado en la base de datos. No obstante este usuario aún no tiene privilegios sobre ninguna base de datos. Vamos a dárselos.

En el usuario juddi que se ha creado nuevo, hacemos click. Seguidamente hacemos click en la pestaña ‘Schema privileges’. Nos aparecerán todas las bases de datos de las que se dispone en el sistema. Tenemos que hacer click en la base de dato juddi. A la derecha nos aparecerán todas las acciones disponibles en esta base de datos. Las seleccionamos todas y hacemos click en el botón (<). Seguidamente volvemos a hacer click en el botón ‘Apply Changes’. Veamoslo en la imagen:

Asignación de privilegios a usuario MySQL

¡Muy bien! Ya lo tenemos todo preparado. Ahora sólo nos falta agregar un usuario al sistema juddi que pueda publicar servicios. Podemos cerrar la ventana de MySQL Administrator. Ahora vamos a abrir la aplicación MySQL Query Browser. Esta aplicación nos va a servir para administrar los datos de MySQL y hacer consultas. Para el acceso al programa más de lo mismo: usuario root, password, localhost… Pero la base de datos que nos exigen para poder entrar será juddi. Dentro del programa buscamos la tabla ‘Publisher’ y hacemos dos veces doble click en ella. Así se nos debe quedar la ventana:

Ventana de MySQL Browser. Tabla de Publicadores.

Bien, si os fijáis a la parte de abajo central de la ventana hay un botón llamado ‘Edit’. Debemos de presionar este botón ya que vamos a incorporar nuevos datos en la base de datos. Hecho esto introduciremos los datos. ¿Qué datos? Pues estos:

• Publisher_ID = juddi.
• Publisher_Name = juddi.
• Email_Address = <tu correo electrónico>
• Is_Admin = true.
• Is_Enabled = true.

Veamos cómo queda esto:

Datos introducidos en la tabla de Publicadores

Bien, hecho esto le damos al botón ‘Apply Changes’ que hay al lado del botón ‘Edit’ que hemos presionado anteriormente. Con esto hecho correctamente, ya tenemos todo el MySQL preparado. Vamos a preparar ahora el tomcat.

Preparación del servidor Tomcat

Lo primero que tenemos que hacer en tomcat es descargar de la página de MySQL el conector JDBC. Para ello entra en la página y descárgarlo. Se encuentra en la sección Downloads -> Connector -> Connector J -> J 5.1. Cuando descargas el archivo comprimido dentro encontrarás un archivo llamado mysql-connector-java-<version>-bin.jar, ese es. Cogemos ese archivo y lo copiamos dentro de la carpeta $CATALINA_HOME/lib. Con eso ya tenemos el conector preparado (una cosa menos).

Ahora nos falta preparar el servidor para que acepte el juddi. Para ello debemos de entrar al directorio conf del $CATALINA_HOME y editar el archivo server.xml. Dentro de este archivo buscamos la etiqueta <HOST …>. Dentro de esta etiqueta (esto es entre <host…> y </host>) pegamos el siguiente texto:

<Context path=”/juddi” docBase=”juddi” debug=”5″ reloadable=”true” crossContext=”true”>
<Resource name=”jdbc/juddiDB” auth=”Container” type=”javax.sql.DataSource”
maxActive=”100″ maxIdle=”30″ maxWait=”10000″
username=”juddi” password=”juddi” driverClassName=”com.mysql.jdbc.Driver”
url=”jdbc:mysql://localhost:3306/juddi?autoReconnect=true”/>
</Context>

Guardamos el archivo y lo cerramos.

¡Si! Ya está. Ya lo tenemos nenes! Preparado y listo para servir. Arrancamos el servidor de tomcat y si no nos da ninguna excepción es que ya lo tenemos correcto.

Prueba del servicio juddi

Para probar el servicio juddi lo único que tenemos que hacer es acceder a la siguiente dirección: http://localhost:8080/juddi/happyjuddi.jsp.

Nos aparecerá algo como esto que indicará que el servicio se ha arrancado correctamente:

Ventana principal de Juddi

Bueno, espero que todos hayáis conseguido montarlo.

Salu2 a todos y ¡hasta otra! 

Como montar un servidor Tomcat

Buenos días chavalotes.

El tema de hoy no es otro que ver cómo podemos montar y configurar un servidor Tomcat para nuestras necesidades que imagino variarán de un lector a otro. Como se que es difícil establecer un sistema operativo con el que acertar con cualquier lector, voy a explicar cómo hacerlo en dos distintos: linux y windows.

Lo primero que tenemos que hacer es descargar los paquetes de tomcat. Para ello entramos en la página http://tomcat.apache.org/. No molestaros en buscar el paquete que concuerde con vuestro sistema operativo, para todos es el mismo. Esto tiene sus ventajas e inconvenientes.Ventaja: No hay que andar buscando cuál es el de nuestro sistema operativo. Además los desarrolladores tienen un quebradero de cabeza menos. Desventaja: El paquete que descargamos suele ocupar más, ya que sabemos que los binarios de linux no son compatibles con los de windows. No obstante la mayoría de los ficheros del paquete son compartidos por ambos sistemas operativos.

Bueno después de esta disertación sobre qué es lo mejor y lo peor de las distribuciones de apache tomcat vamos a centrarnos en lo que tenemos que hacer. Dentro de la página de apache nos descargamos el núcleo de la aplicación (llamado en ésta core). El nombre del archivo a descargar será algo como apache-tomcat-<versión>.zip. En este post se ha utilizado la versión 6.x de la aplicación. Os recomiendo que utilicéis la misma que yo he utilizado porque con versiones antiguas suelen tener algunas diferencias. Pequeñas, pero al fin y al cabo son diferencias y si estáis leyendo este post es porque no sois expertos en el tema. Por eso cuanto menos problemas mejor.

Ya tenemos el archivo descargado. Ahora procedemos a descomprimirlo en la carpeta donde lo vamos a alojar. Aquí es cuando empiezo a explicarlo en dos sistemas operativos distintos:

Windows

En windows se suelen instalar los programas en la carpeta ‘Archivos de programa’. Pues bien, ¿porqué no?, vamos a dejarlo ahí. Descomprimimos el contenido del zip dentro de esta carpeta. Yo sugiero cambiar el nombre de la carpeta descomprimida por algo más práctico. Normalmente se descomprime como apache-tomcat-<version>. Yo la cambié por tomcat. Así, fácil, práctico. Hecho esto ya tenemos tomcat ‘instalado’ en C:/Archivos de programa/tomcat (¡BIEN! que listos somos). A partir de ahora a esta dirección la llamaremos: $(CATALINA_HOME).

Vamos a configurar ahora el servidor para que funcione. Si abrimos una ventana de MS-DOS y accedemos a $(CATALINA_HOME) veremos que existen distintas carpetas. Las que nos importan a nosotros son:

- Conf: Dentro se encuentran los ficheros de configuración del servidor.

- Webapps: Dentro de esta carpeta se van a incorporar nuestros trabajos, páginas web, etc.

- Lib: Librerías necesarias para que el servidor funcione.

Lo primero que tenemos que hacer es configurar los usuarios (archivo tomcat-users.xml dentro de la carpeta Conf) que vamos a tener dentro del servidor. Obviamente no necesitamos más que un usuario de manejo del servidor. Aquí os dejo cómo debería quedar el XML de usuarios:

<?xml version=’1.0′ encoding=’utf-8′?>
<tomcat-users>
<role rolename=”manager”/>
<role rolename=”admin”/>
<user username=”usuario” password=”contrasena” roles=”manager”/>
</tomcat-users>

Hecho esto ya tenemos el servidor configurado. Lo siento mucho si os habéis hecho ilusiones, pero esto aún no funciona  . Pero por poco tiempo. Nos faltan un par de minucias que vamos a solucionar rápidamente.

Para que esto empiece a funcionar necesitamos configurar las variables de entorno que indican dónde se encuentra instalado tomcat y jre (la máquina virtual de java). Para ello nos vamos al escritorio. En el icono de Mi PC hacemos click derecho y seleccionamos ‘Propiedades’. En la pestaña de ‘Opciones avanzadas’ hacemos click en el botón de ‘Variables de entorno’:

Propiedades de mi pc para las variables de entorno

Al hacer click en este botón accedemos a la ventana de variables de entorno. Existen dos tipos: por usuario y de sistema. Las variables de entorno de usuario sólo ‘funcionan’ cuando el sistema arranca desde el usuario del que la estamos creando. Sin embargo si la hacemos de sistema, la variable de entorno se encuentra activa independiente del usuario utilizado en el sistema. Por lo tanto tendremos que crearnos las variables de entorno de CATALINA_HOME y JRE_HOME. Veamos esto en la imagen:

Ventana de variables de entorno de sistema

Bien, ahora si que estamos preparados para lanzar el Tomcat. No obstante estas variables de entorno no serán activadas hasta que se reinicie el sistema. Así que ya sabes lo que tienes que hacer. Nos vemos en unos minutos  .

Una vez tenemos esto ya solo nos quedan las instrucciones de arrancar y parar el sistema. Esto lo cuento más adelante. Después de la configuración del sistema en linux. Sigue leyendo…

Linux

En linux se suelen instalar los programas en la carpeta /usr/local. Pues bien, ¿porqué no?, vamos a dejarlo ahí. Descomprimimos el contenido del zip dentro de esta carpeta. Yo sugiero cambiar el nombre de la carpeta descomprimida por algo más práctico. Normalmente se descomprime comoapache-tomcat-<version>. Yo la cambié por tomcat. Así, fácil, práctico. Hecho esto ya tenemos tomcat ‘instalado’ en /usr/local/tomcat (¡BIEN! que listos somos). A partir de ahora a esta dirección la llamaremos: $(CATALINA_HOME).

Vamos a configurar ahora el servidor para que funcione. Si abrimos un terminal y accedemos a $(CATALINA_HOME) veremos que existen distintas carpetas. Las que nos importan a nosotros son:

- Conf: Dentro se encuentran los ficheros de configuración del servidor.

- Webapps: Dentro de esta carpeta se van a incorporar nuestros trabajos, páginas web, etc.

- Lib: Librerías necesarias para que el servidor funcione.

Lo primero que tenemos que hacer es configurar los usuarios (archivo tomcat-users.xml dentro de la carpeta Conf) que vamos a tener dentro del servidor. Obviamente no necesitamos más que un usuario de manejo del servidor. Aquí os dejo cómo debería quedar el XML de usuarios:

<?xml version=’1.0′ encoding=’utf-8′?>
<tomcat-users>
<role rolename=”manager”/>
<role rolename=”admin”/>
<user username=”usuario” password=”contrasena” roles=”manager”/>
</tomcat-users>

Hecho esto ya tenemos el servidor configurado. Lo siento mucho si os habéis hecho ilusiones, pero esto aún no funciona  . Pero por poco tiempo. Nos faltan un par de minucias que vamos a solucionar rápidamente.

Para que esto empiece a funcionar necesitamos configurar las variables de entorno que indican dónde se encuentra instalado tomcat y jre (la máquina virtual de java). Para ello nos vamos de nuevo al terminal. Desde el terminal nos vamos a la carpeta de usuario (suele ser /home/<usuario>). Desde esta carpeta editamos el archivo .bashrc. Dentro de este archivo, al final, deberemos de añadir las sentencias que le indican al sistema dónde se encuentra la carpeta de tomcat y la carpeta del jre. Básicamente debemos añadir las siguientes entradas:

export JRE_HOME=/usr/local/java/jre
export CATALINA_HOME=/usr/local/tomcat

Bien, ya tenemos configuradas las variables de entorno necesarias. Aún no están activas. Para activarlas podemos ejecutar la sentencia: $> source .bashrc. No obstante no siempre funciona. Depende de la distribución de linux que estemos utilizando. Lo más seguro es reiniciar. Si reiniciamos seguro que se activan  . Así que ya sabes lo que tienes que hacer. Nos vemos en unos minutos  .

Una vez tenemos esto ya solo nos quedan las instrucciones de arrancar y parar el sistema.

Poniendo en marcha el sistema

La puesta en marcha del sistema es bien sencilla. No obstante varía dependiendo del sistema operativo.

Windows

Para arrancar el sistema en windows va a ser necesario que abramos una ventana de MS-DOS y accedamos al directorio $CATALINA_HOME. Entramos al directorio bin. Desde éste ejecutamos la sentencia:

catalina.bat start

Bingo! se nos abre una nueva ventana de MS-DOS llamada Tomcat y en la que empezamos a ver cómo se van activando los servicios de éste.

Linux

Para arrancar el sistema en linux va a ser necesario que abramos un terminal y accedamos al directorio de $CATALINA_HOME. Desde aquí entramos al directorio bin. Hecho esto ejecutamos la siguiente sentencia en el terminal:

sh catalina.sh start

Bingo! en el terminal comienzan a aparecer los directorios de las variables de entorno indicándonos que todo es correcto.

NOTA: Una vez que hemos terminado de utilizar el servidor, podemos pararlo ejecutando la misma sentencia pero cambiando la palabra ‘start’ por ‘stop’.

Prueba del sistema

Una vez tenemos arrancado podemos probar su correcto funcionamiento accediendo a un navegador web. Si, lo que estás utilizando para leer este post. Desde éste accedemos a la dirección http://localhost:8080. Se nos ha de abrir la ventana de bienvenida de tomcat. Si esto es así, ya hemos terminado. Lo tenemos correcto. Si el navegador nos indica que no encuentra la página, mal asunto amigo. En algo te has equivocado y te toca repasar todos los pasos dados en este post.

Ventana principal de Tomcat

¿Qué hacer con tomcat?

Obviamente el que ha montado un servidor así es porque tiene claro para qué lo va a utilizar. No obstante no tengo ningún problema en decir que en la carpeta $CATALINA_HOME/webapps se han de incorporar las páginas web, .war, etc que queremos que el servidor nos aloje.

Salu2 a todos, BLAKEscIence.

Web Services en Java (ahora con Tomcat)

Buenas noches amiguetes de la taza:

Hace unos días subí un post sobre cómo crear servicios web en java utilizando el servidor de aplicaciones de Sun. Esto es el servidor GlassFish. Bien, hoy vuelvo a dirigirme al lector volviendo a hablar de los servidores web en java. En este caso vamos a utilizar para lanzarlo el servidor de aplicaciones Apache Tomcat 6.x. Muchos pueden opinar que la versión 5.5 de esta aplicación es más estable, más rápida, más bonita… o que simplemente le gusta más. Por mi estupendo, pero yo lo he hecho con la versión 6.x por su sencillez. La cual no he encontrado en las versiones anteriores.

Para comenzar lo lógico y normal es tener un servidor de Apache Tomcat 6.x funcionando. Pero claro, se que habrá alguno que esto ya se le queda grande. Por esta razón en unos días publicaré cómo montar este servidor. Pero por hoy voy a partir desde la base de que ya tenemos montado y funcionando tomcat en nuestro ordenador (o en otro al que tengamos acceso y administración).

Para preparar el tomcat para arrancar servicios web (también llamado ‘deploy’ y a partir de ahora lo llamaré así) necesitamos las librerías de deploy. Las encontraremos en la página web de tomcat. Si accedemos a ella podremos descargarlo en un zip, suele llamarse algo así como ‘deployer’. Dentro de este zip encontramos varias carpetas y archivos. Lo que nos importan a nosotros es la carpetalib y el archivo build.xml. El contenido de la carpeta lib debemos de copiarlo dentro de la carpeta lib del directorio de tomcat. Esto es, si estamos en linux y tenemos tomcat en /usr/local/tomcat, tendremos también una carpeta lib en /usr/local/tomcat/lib (En windows sería algo como C:/Archivos de programa/Tomcat por ejemplo). Debemos de copiarlos dentro de esta carpeta. Lo mismo haremos con el archivo build.xml, pero éste lo copiaremos a la carpeta conf del directorio de instalación de tomcat. De esta manera ya hemos instalado el deployer.

No hemos acabado aún los preparativos, nos falta instalar Axis2. Axis2 es el que nos va a hacer el autodeploy de nuestros servicios web. La instalación de éste es bastante más sencilla. ¿Más sencilla aún que copiar una serie de archivos en una carpeta? Pues si, porque sólo hay que copiar un archivo xD. Para ello accedemos a la página web de axis2: http://ws.apache.org/axis2. Descargamos el archivo war de axis2. Este archivo se descarga en un zip y dentro tenemos el axis2.war. Este archivo debemos de meterlo dentro del directorio webapps del servidor tomcat (si no sabes dónde se encuentra este directorio, mal vas -> <directorio_tomcat>/webapps). Hecho esto detenemos el servicio de tomcat y volvemos a lanzarlo.

¡BIEN! ya tenemos todo lo necesario para comenzar y para terminar. Si si, terminar. Montar un servicio web cuando ya tenemos todo el chiringuito montado es una tontería. Creamos un servicio web con netbeans (debemos de crear el servicio web con un servidor por defecto de tomcat. Sino lo hacemos así no funcionará). Recomiendo ver el post de cómo crear un servicio web con netbeans (tu haz lo que quieras. También puedes pensar: -yo soy un macho, me lo voy a currar sin mirar que aprendo más. -Pues nada, a tu rollo).

Cuando tenemos creado el servicio web de netbeans, cogemos el .war que nos ha generado y lo copiamos exactamente en la misma carpeta donde copiamos el de axis2, esto es en la carpeta dewebapps. Hecho esto detenemos el servicio y volvemos a lanzarlo.

¡YA ESTÁ! si tio, se acabó la historia. El servidor tomcat 6.x tiene por defecto la estupenda costumbre de autoarrancar los .war que dejamos en webapps. ¿Cómo?, ¿que no te lo crees?… (hombre/mujer de poca fe) ¡Que no joder!, ¡Hay que probarlo!

Para probar el servicio web tenemos que tener claros los nombres que hemos utilizado al crear el servicio web. Por un lado tenemos el nombre del archivo que es el nombre que acompaña al .war que hemos copiado en webapps. Por otro lado tenemos el nombre del servicio web. Este nombre es el que le pusimos cuando creamos en el proyecto el servicio web. Para ver si el servicio web ha sido lanzado por nuestro servidor accedemos al servidor tomcat: http://localhost:8080. Hecho esto accedemos a la parte de mantenimiento: ‘Tomcat Management’:

Ventana principal de Tomcat

Una vez dentro encontramos todos los servicios arrancados. En nuestro ejemplo no hemos montado ninguno. Pero por ejemplo tenemos el de Axis2 que hemos copiado antes. Si nuestro archivo se llamaba calculadora.war, debería de aparecer una entrada con el nombre: calculadora/.

Si, ya se que esto es muy bonito, y soy consciente de que lo que queréis es cómo acceder al WSDL. Al fin y al cabo es lo más interesante de todo esto. Para ello accederemos a la página: http://localhost:8080/<nombre_del_archivo>/<nombre_del_servicio>?wsdl. ¿Y con esto ya está?Pues si, si consigues acceder al XML que describe el servicio web, ya tienes el servidor preparado para aceptar peticiones al servicio web. Por otro lado puedes acceder a la página web para probar el servicio: http://localhost:8080/<nombre_del_archivo>/<nombre_del_servicio>?wsdl.

Bueno, espero haber sido de ayuda en vuestras dudas.

Salu2 a todos  .

Web Services en Java

Bueno chavalines, vamos a explicar cómo montar un servicio web con Java desde ’0′. Esto implica la creación del servicio web y su publicación.

Creación del servicio web

Para la creación del servicio web vamos a utilizar la página web de netbeans (www.netbeans.org). En dicho enlace nos exlican paso a paso cómo crear el servicio web. Deberemos seguir estos pasos hasta completar un servicio web funcional. Como ejemplo nos vale el que nos muestra el tutorial.

Para ello debemos de entrar en el siguiente enlace: http://www.netbeans.org/kb/60/websvc/jax-ws.html

Deberemos de prestar especial atención al lugar donde creamos el proyecto. Una vez terminado éste, deberemos de crear la distribución de la aplicación. Esta distribución seremos la que publicaremos para poder consumir el servicio web. Para crear esta distribución haremos click derecho en la ventana de proyectos encima del correspondiente al servicio web creado. Haremos click en la opción clean and build. Automáticamente tendremos la distribución creada. Podemos ver que realmente se ha creado si accedemos a la carpeta del proyecto y dentro de ella entrar en la carpeta dist. Veremos que nos ha generado un fichero acabado en WAR, esto es, nos habrá generado un fichero del modo: <nombre_del_proyecto>.war.

Publicación del servicio web

Bueno, hemos llegado a la parte de la que menos información se encuentra en internet: la publicación del servicio web. Para ello necesitamos localizar el .war generado por el IDE de netbeans. Una vez lo tenemos localizado pasaremos a instalar el servidor de aplicaciones. Vamos a utilizar GlassFish. Para ello necesitamos entrar en la página web www.java.sun.com y descargarlo. La aplicación en si se llama: java sun application server.

Una vez la tenemos instalada y corriendo en el sistema, hemos de entrar al administrador web del programa. Para ello accedemos a la página web: http://localhost:4848. Durante la instalación nos pregunta que puerto queremos utilizar. Recomiendo no cambiar el puerto y utilizar el que el programa nos da por defecto: 4848. Si no conseguimos abrir la página el servidor de aplicaciones no se ha lanzado correctamente. Podemos buscar en el menú de inicio las herramientas para arrancarlo.

Una vez hemos accedido al administrador web del servidor de aplicaciones (SJAS) haremos click en la opción Aplicaciones -> Aplicaciones Web. En un principio no nos aparecerá ningún servicio web implementado. Para introducir el nuestro haremos click en el botón Implementar…

Como consecuencia accederemos a la página de crear una nueva implementación del servicio web. Nos aparece un desplegable para elegir el tipo de archivo a importar para la implementación. Nosotros como ya hemos comentado algunas líneas más arriba tenemos generado un archivo .war. Por lo tanto el la opción tipo seleccionaremos Aplicación web (.war). En cuanto a la ubicación el sistema nos da por defecto la opción El archivo empaquetado se cargará en el servidor. Acto seguido deberemos de presionar el botón Examinar… Esto nos permitirá buscar y seleccionar el fichero .war generado por netbeans. Cuando lo tengamos le pondremos un nombre a la aplicación. Las demás opciones las dejaremos tal cual.

Hecho esto ya tenemos el servicio web operativo y funcionando. Para comprobar su correcto funcionamiento volvemos a fijar uestra atención en el menú de la izquierda. En éste seleccionamos la opción Servicios web. Veremos como el nuevo servicio web recién implementado nos aparece aquí. También podemos ver que nos aparece una tabla con el servicio web creado. Aquí nos aparecerán todos los servicios web implementados. Podemos seleccionar la opción ver WSDL para comprobar los servicios ofrecidos por éste.

También podemos seleccionar el servicio web directamente del menú, esto nos abrirá la información de éste. Aquí podremos hacer click en el botón Probar. Este botón nos va a llevar a la página web que nos permite probar el servicio web.

En una misma máquina todas las direcciones son del estilo: http://localhost… En el caso de montar el ‘chiringuito’ en otro ordenador de la red, todas las instrucciones dadas son válidas. Aunque para los accesos utlilzaremos las direcciones de eta manera: http://<ip_servidor>…

¿Podemos acceder a un WS desde fuera de la red local?

Esta cuestión queda fuera del objetivo de este post. No obstante voy a dar un pequeña pista. Para acceder a un WS montado en un equipo A con una ip B, tendremos que crear en el router una entrada en la tabla de reglas NAT de éste del tipo: desde ip 0.0.0.0 puerto 4848 ip B. Lo que es lo mismo: redireccionar cualquier tráfico de información a través del puerto 4848  la ip B.

Espero haber solucionado algunas dudas con respecto a este tema de los servicios web. Un saludo y suerte!