lunes, 19 de septiembre de 2016

Secure Admin must be enabled to access the DAS remotely

En este corto artículo les presento la solución al error:

Secure Admin must be enabled to access the DAS remotely

Que ocurre cuando queremos acceder remotamente a un servidor glassfish recientemente instalado. La solución es tan sencilla como ejecutar el siguiente comando:

asadmin --host [host] --port [port] enable-secure-admin


Recuerden reiniciar el servicio para que los cambios tomen efecto. Saludos!

martes, 13 de septiembre de 2016

How to Install and Configure MySQL Cluster on Windows

MySQL Clúster es una versión de alta disponibilidad, alta redundancia de MySQL adaptada para el entorno de computación distribuida. Usa el motor de almacenamiento NDB Cluster para permitir la ejecución de varios servidores MySQL en un clúster. Este motor de almacenamiento está disponible en las distribuciones binarias de MySQL 5.0, Los sistemas en los que está disponible son Linux, Solaris y Windows. En este artículo vamos a revisar la manera cómo configurarlo.

La infraestructura que utilizaremos será la siguiente:


Los requerimientos son los siguientes:


Las recomendaciones son estas:

  • Desactivar firewall
  • Desactivar antivirus
  • Desinstalar y limpiar versiones anteriores de MySQL

Una vez descargada la versión, descomprimir el contenido en una carpeta en el disco C, a la cual llamaremos mysqlc.

En cada uno de los tres nodos de la figura mostrada anteriormente, crear la estructura de carpetas y su contenido a partir del comando:
C:\>mkdir my_cluster my_cluster\ndb_data my_cluster\mysqld_data my_cluster\conf
C:\>mkdir my_cluster\mysqld_data\mysql my_cluster\mysqld_data\ndbinfo
C:\>copy c:\mysqlc\data\mysql my_cluster\mysqld_data\mysql 
C:\>copy c:\mysqlc\data\ndbinfo my_cluster\mysqld_data\ndbinfo

Nodo Administrador
Crear el archivo config.ini en la carpeta c:\my_cluster\conf con el siguiente contenido:
[ndb_mgmd]
HostName=192.168.1.100
DataDir=c:\my_cluster\ndb_data
Nodeid=1

[Ndbd default]
NoOfReplicas=2

[Ndbd]
HostName=192.168.1.101
Nodeid=3

[Ndbd]
HostName=192.168.1.102
Nodeid=4
[Mysqld]
[Mysqld]
Iniciar el nodo administrador ejecutando el siguiente comando y dejando la consola abierta.
C:\my_cluster>/mysqlc/bin/ndb_mgmd -f conf/config.ini --initial --configdir=c:\my_cluster\conf\
En otra consola de comandos del nodo administrador, ejecutar el programa para verificar el estado de nuestro cluster.
C:\>C:\mysqlc\bin\ndb_mgm -e show
El resultado deberá ser similar al mostrado a continuación:


Nodos de Datos
En cada uno de los nodos de datos, crear el archivo my.cnf en la carpeta c:\my_cluster\conf. El puerto debe ser diferente para cada nodo de dato y de preferencia mayor a 5000.
[mysqld]
ndbcluster
datadir=c:\my_cluster\mysqld_data
port=15002
ndb-connectstring = 192.168.1.100

[mysql_cluster]
ndb-connectstring = 192.168.1.100
Ahora nos conectamos con el nodo administrador ejecutando el siguiente comando en cada uno de los dos nodos de datos
C:\>c:\mysqlc\bin\ndbd -c 192.168.1.100:1186
Sin embargo, al ejecutar en el nodo administrador el siguiente comando.
C:\>C:\mysqlc\bin\ndb_mgm -e show
Podemos notar que, a pesar que la conexión al nodo administrador ha sido hecha, los nodos SQL aún no están habilitados (not connected, accepting connect from any host).


Para levantar las API's, ejecutar en cada nodo de datos el siguiente comando en una consola nueva:
C:\my_cluster>c:\mysqlc\bin\mysqld --defaults-file=conf/my.cnf --console
Al volver a ejecutar el comando de visualización de conexiones en el nodo administrador, la salida será la siguiente:


Ahora sólo resta conectarnos al motor de base de datos de cada nodo utilizando una nueva consola para ejecutar el siguiente comando, teniendo en cuenta el puerto establecido en el archivo my.cnf. En este caso, mostraremos la conexión en el nodo que utiliza el puerto 15002.
c:\my_cluster>c:\mysqlc\bin\mysql -P15002 -u root
Al levantar los dos motores, cualquier sentencia SQL ejecuta en uno de ellos deberá verse automáticamente reflejada en la otra instancia. La siguiente imagen ilustra esto:


Inicialmente, en la consola azul habían las mismas base de datos que en la consola blanca, sin embargo al crear la base de datos clusterdb en esta última, la instancia azul reflejó automáticamente los cambios.

Para finalizar, les dejo los comandos para finalizar el servicio de manera segura:
#Ejecutar por cada nodo de datos, teniendo en cuenta el puerto
C:\my_cluster>c:\mysqlc\bin\mysqladmin -u root -h 127.0.0.1 -P15000 shutdown
#Nodo administrador
C:\my_cluster>c:\mysqlc\bin\ndb_mgm -e shutdown
#Ver puertos
netstat -oan

lunes, 12 de septiembre de 2016

How to use Java 8 predicate

Las expresiones lambda son funciones anónimas, es decir que no necesitan una clase. Su sintaxis básica se muestra a continuación:

parámetros → {Cuerpo lambda}

En caso de que el cuerpo lambda presenta más de una línea de código, será necesario incluir las llaves. En caso devuelva un valor, será necesario incluir también la cláusula return.

A continuación, mostraré algunos ejemplos del uso de predicados utilizando funciones lambda. Recuerden que estas características sólo están disponibles en la versión 8 del JDK.

Predicado simple
Representa una función con un único argumento cuyo valor de retorno será de tipo booleano. Aplicaremos este caso para verificar si un número es primo o no.

import java.util.function.Predicate;
import java.util.stream.IntStream;

/**
 *
 * @author Rolando
 */
public class Main {

    public static void main(String[] args) {
        System.out.println(isPrimo(1));
        System.out.println(isPrimo(2));
        System.out.println(isPrimo(3));
        System.out.println(isPrimo(4));
    }

    private static boolean isPrimo(final int numero) {
        Predicate<Integer> isDivisible = divisor -> numero % divisor == 0;
        return numero > 1 && IntStream.range(2, numero).
                noneMatch(index -> isDivisible.test(index));
    }
}

Encadenamiento de predicados
Los predicados también puede ser encadenados entre sí utilizando conectores de tipo AND, OR y de negación como si de cualquier expresión lógica se tratase. A continuación, se muestra un ejemplo sencillo en donde se verifica, a través de dos predicados, que un número se encuentra en un rango determinado.
import java.util.function.Predicate;

/**
 *
 * @author Rolando
 */
public class Main {

    public static void main(String[] args) {
        System.out.println(isInRange(7, 2, 8));
        System.out.println(isInRange(9, 11, 15));
    }

    private static boolean isInRange(final int numero, final int limiteInferior, final int limiteSuperior) {
        Predicate<Integer> mayorNumero = i -> i >= limiteInferior;
        Predicate<Integer> menorNumero = i -> i <= limiteSuperior;
        return limiteSuperior >= limiteInferior && mayorNumero.and(menorNumero).test(numero);
    }
}

Predicados como argumentos de funciones
Java 8 también nos permite pasar predicados como argumentos de funciones. En el siguiente ejemplo, sólo vamos a permitir números que cumplan con la regla que es establecida como parámetro de la función procesar.
import java.util.function.Predicate;

/**
 *
 * @author Rolando
 */
public class Main {

    public static void main(String[] args) {
        procesar(11, (i) -> i > 10);
        procesar(9, (i) -> i % 3 == 0);
    }

    /**
     * Función que recibe un predicado como parámetro
     *
     * @param number
     * @param predicate
     */
    static void procesar(int number, Predicate<Integer> predicate) {
        if (predicate.test(number)) {
            System.out.println("Número " + number + " ha sido aceptado!");
        }
    }
}

También podemos filtrar elementos de una lista utilizando predicados. El siguiente ejemplo lo ilutra:
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 *
 * @author Rolando
 */
public class Main {

    public static void main(String[] args) {
        List<Usuario> users = new ArrayList<>();
        users.add(new Usuario("John", "admin"));
        users.add(new Usuario("Peter", "member"));
        List<Usuario> lstAdministradores = process(users, (u) -> u.getUsuario().equals("admin"));
        System.out.println(lstAdministradores.size());
    }

    static List<Usuario> process(List<Usuario> users, Predicate<Usuario> predicate) {
        List<Usuario> result = new ArrayList<>();
        for (Usuario user : users) {
            if (predicate.test(user)) {
                result.add(user);
            }
        }
        return result;
    }
}

class Usuario {

    private String nombre;
    private String usuario;

    public Usuario(String nombre, String usuario) {
        this.nombre = nombre;
        this.usuario = usuario;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getUsuario() {
        return usuario;
    }

    public void setUsuario(String usuario) {
        this.usuario = usuario;
    }
}

lunes, 29 de agosto de 2016

How to set up a JDBC Connection Pool on Glassfish

Un pool de conexiones es una clase java que tiene abiertas varias conexiones a base de datos. Cada vez que un programa cliente necesita comunicarse con una base de datos, establece una conexión, generalmente utilizando un protocolo especializado. Esta conexión, generalmente se mantiene abierta el tiempo que dura la ejecución del programa y sólo es cerrada al finalizar el trabajo de la aplicación con la base de datos.

Este artículo muestra la secuencia de pasos a seguir para poder configurar un pool de conexiones en un servidor de aplicaciones Glassfish. Los pasos a seguir son los siguientes:


Luego de configurado el nombre y seleccionado el motor de base de datos, debemos especificar ciertos parámetros de conexión. Si alguno de ellos no existe, se podrá agregar haciendo clic en el botón Add Property.


Podemos hacer una prueba del funcionamiento de nuestro pool de conexiones haciendo clic en el botón Ping.


Si al hacer clic en Ping les aparece el siguiente error: "Ping Connection Pool failed for SakilaPool. Class name is wrong or classpath is not set for : com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource Please check the server.log for more details.", no desesperen. Este error se debe a que no se encuentra la biblioteca correspondiente al conector MySQL en el dominio del servidor.

La solución es muy sencilla, sólo debemos colocar el archivo de extensión jar en su lugar correspondiente y reiniciar el servicio.



Volvemos a hacer ping al JDB Connection Pool y la respuesta debería ser como la que se muestra a continuación.


Ahora sólo basta configurar el acceso al pool como recurso nombrado. Para esto, hacer clic en el botón New de la pantalla que se muestra a continuación:


Y luego hacer clic en OK. Con esto tendremos configurado todo y sólo restaría hacer consultas de prueba a la base de datos a través del pool de conexiones.


Para realizar las pruebas debemos crear un proyecto Java Web y en la página de inicio deberá ser similar a:

<%@page import="java.sql.ResultSet"%> 
<%@page import="java.sql.Statement"%> 
<%@page import="javax.sql.DataSource"%> 
<%@page import="java.sql.Connection"%> 
<%@page import="javax.naming.InitialContext"%> 
<%@page import="javax.naming.Context"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <%
            Context ctx = new InitialContext();
            DataSource ds = (DataSource) ctx.lookup("jdbc/sakila");
            Connection con = ds.getConnection();
            if (con != null) {
                Statement st = con.createStatement();
                ResultSet rs = st.executeQuery("SELECT * FROM actor");
                out.print("<table>");
                while (rs.next()) {
                    out.print("<tr>");
                    out.print("<td>" + rs.getString("first_name") + "</td>");
                    out.print("<td>" + rs.getString("last_name") + "</td>");
                    out.print("</tr>");
                }
                out.print("</table>");
                rs.close();
                st.close();
                con.close();
            }%>
    </body>
</html>
La salida deberá verse así:


Espero este artículo les sea de utilidad. Cualquier pregunta, no duden en comentarla.

jueves, 25 de agosto de 2016

Authentication with JAX-WS SOAP header

Una de las formas más comunes de autenticación en servicios Web es a través de credenciales del tipo usuario y contraseña, agregados como cabeceras en una solicitud SOAP. En este artículo les voy a mostrar la manera cómo enviar estos parámetros desde el cliente hacia el servidor, en donde serán recuperados para posteriormente ejecutar la lógica de autenticación requerida.

Como primer paso, se debe crear en Netbeans un proyecto Java Web para luego crear la estructura de paquetes que se muestra a continuación.


Se debe crear una Interface Notificador en donde se declarará el método que será implementado por nuestro servicio Web. En este caso, la funcionalidad a implementar será la de responder con un saludo a un nombre que se recibirá como parámetro.
package com.rolandopalermo.blog.interfaces;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService
public interface Notificador {

    @WebMethod
    public String saludar(String nombre);
}

Como se puede apreciar, dos anotaciones fueron agregadas. La primera es @WebService y se utiliza para indicar que una clase está implementando un servicio Web o que una Service Endpoint Interface está implementando una interfaz de servicio Web. La segunda anotación, @WebMethod, indica que un método es una operación de servicio Web.

Ahora toca implementar la interfaz creada anteriormente. Dicha implementación se realizará a través de un servicio Web, tal como se muestra a continuación:



/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.rolandopalermo.blog.ws;

import com.rolandopalermo.blog.interfaces.Notificador;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.jws.WebService;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;

@WebService(serviceName = "NotificadorImpl")
public class NotificadorImpl implements Notificador {

    @Resource
    private WebServiceContext wsc;

    @Override
    public String saludar(String nombre) {
        /*Lectura de parámetros de cabecera SOAP*/
        MessageContext mc = wsc.getMessageContext();
        Map requestHeader = (Map) mc.get(MessageContext.HTTP_REQUEST_HEADERS);
        List usuarioList = (List) requestHeader.get("usuario");
        List passwrdList = (List) requestHeader.get("password");
        //***************************************************
        String usuario = "";
        String password = "";
        if (usuarioList != null && passwrdList != null) {
            usuario = (String) usuarioList.get(0);
            password = (String) passwrdList.get(0);
            if (usuario.equals("admin") && password.equals("123456")) {
                if (nombre != null && nombre.length() > 0) {
                    return "Hola " + nombre;
                }
                return "Error";
            } else {
                return "Error de autenticación";
            }
        } else {
            return "Se requiere campos de autenticación";
        }
    }
}
El último paso que resta, en el lado del servidor, sería el despliegue del proyecto. Para esto, hacer lo siguiente:


Y para finalizar, sólo resta escribir el código correspondiente a los clientes. Para el caso de Netbeans, se tendría que crear un servicio Web cliente con el WSDL del servicio Web. Si no enviamos los parámetros de autenticación, la respuesta del servicio será la siguiente:


Por otra parte, si enviamos los parámetros requeridos, tal como se muesta a continuación, la respuesta debe ser la correspondiente a un usuario correctamente autenticado.
package com.rolandopalermo.blog.cliente;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.handler.MessageContext;

public class Main {
    
    private static final String WS_URL = "http://localhost:8080/SOAPAuthentication/NotificadorImpl?wsdl";
    
    public static void main(String[] args) {
        
        com.rolandopalermo.blog.ws.NotificadorImpl_Service service = new com.rolandopalermo.blog.ws.NotificadorImpl_Service();
        com.rolandopalermo.blog.ws.NotificadorImpl port = service.getNotificadorImplPort();
        
        Map<String, Object> req_ctx = ((BindingProvider)port).getRequestContext();
        req_ctx.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, WS_URL);

        Map<String, List<String>> headers = new HashMap<String, List<String>>();
        headers.put("usuario", Collections.singletonList("admin"));
        headers.put("password", Collections.singletonList("123456"));
        req_ctx.put(MessageContext.HTTP_REQUEST_HEADERS, headers);
        
        System.out.println(port.saludar("Rolando"));
        
    }
}

Al ejecutar dicho código, la respuesta será la siguiente:


Código fuente del proyecto:


Espero que este post les sea de utilidad. Cualquier consulta, no duden de escribirla en la caja de comentarios, saludos!

viernes, 30 de octubre de 2015

Enviar correo con Matlab y Gmail


UserName = 'emisor@gmail.com';
passWord = '';
setpref('Internet','E_mail',UserName);
setpref('Internet','SMTP_Server','smtp.gmail.com');
setpref('Internet','SMTP_Username',UserName);
setpref('Internet','SMTP_Password',passWord);
props = java.lang.System.getProperties;
props.setProperty('mail.smtp.auth','true');
props.setProperty('mail.smtp.socketFactory.class', ...
                  'javax.net.ssl.SSLSocketFactory');
props.setProperty('mail.smtp.socketFactory.port','465');
emailto = 'receptor@gmail.com'; % recipient's email
sendmail(emailto, 'My Subject', 'My message');

miércoles, 23 de septiembre de 2015

Obtener imagen de Cámara IP con Matlab


% Obtener imagen de cámara IP
clc;
clear;
figure;
while(1)
%--Definición de variables
url='http://192.168.2.157/image/jpeg.cgi'; 
snapshot1='image_cam_1.jpg';
user='admin';
pass='admin';
%--
urlwrite(url,snapshot1,'Authentication','Basic','Username',user,'Password',pass);
I1 = imread(snapshot1);
imshow(I1);
delete(snapshot1);
end

Sensor HC-SR04 de ultrasonido y Arduino Mega 2560

#define PIN_TRIG 12
#define PIN_ECO  13

void setup() {
  // Inicializacion de la comunicacion serial
  Serial.begin (9600);
  // Inicializacion de pines digitales
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECO, INPUT);
}

void loop() {
  long duracion, distancia;  // Variables
  /* Hacer el disparo */
  digitalWrite(PIN_TRIG, LOW);  
  delayMicroseconds(2); 
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  /* Recepcion del eco de respuesta */
  duracion = pulseIn(PIN_ECO, HIGH);
  /* Calculo de la distancia efectiva */
  distancia = (duracion/2) / 29;
  /* Imprimir resultados a la terminal serial */
  if (distancia >= 500 || distancia <= 0){
    Serial.println("Fuera de rango");
  }
  else {
    Serial.print(distancia);
    Serial.println(" cm");
  }  
  // Retardo para disminuir la frecuencia de las lecturas
  delay(500);  
}

Leer entrada analógica en Arduino con potenciómetro

Lee la entrada analógica A0 cuyo valor está determinado por un potenciómetro y lo muestra a través de la consola serial.
void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(1);
}

Encender un led con Arduino

void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}