Archivo

Archive for the ‘Linux’ Category

PushServer + Jetty + Primefaces + WebSockets = PrimePush

abril 10, 2012 6 comentarios

Después de haber recorrido internet buscando a una solución para implementar AjaxPush con el framework para JSF de Primefaces 3, pues al fin lo he logrado, como nos comentan los creadores de primefaces dentro de la documentación oficial, para hacer este tipo de implementaciones es necesario crear un servidor paralelo a nuestra aplicación, este va ser un servidor de Push y se va a encargar exclusivamente de ese trabajo, conservando nuestro proyecto mucho más modular y escalable. Actualmente nos dicen que solo existe soporte para el servidor push implementado con las librerías de jetty, así que para comprobarlo he realizado unas cuantas pruebas obteneniendo un resultado excelente. Como se realizó esto lo voy a mostrar ahora:

  1. Lo primero que debemos hacer es descargar la librería de Jetty, en este casó la última versión que he podido encontrar es Jetty 8.1.2.
  2. Luego voy a crear un proyecto java estándar como los de escritorio o de consola en Netbeans 7.1.
  3. Agregar estas librerías al proyecto.
    jetty-websocket-8.1.2.v20120308.jar
    servlet-api-3.0.jar
    jetty-server-8.1.2.v20120308.jar
    jetty-servlet-8.1.2.v20120308.jar
    jetty-annotations-8.1.2.v20120308.jar
    jetty-io-8.1.2.v20120308.jar
    jetty-util-8.1.2.v20120308.jar
    jetty-http-8.1.2.v20120308.jar
    jetty-security-8.1.2.v20120308.jar
    jetty-continuation-8.1.2.v20120308.jar
  1. Creamos una clase principal con un método main como está.
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import servlet.PushServlet;

/**
* @author christmo
*/
public class JettyServerPush {

    public static void main(String[] args) throws Exception {
        Server server = new Server(8081);

        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        server.setHandler(context);

        context.addServlet(new ServletHolder(new PushServlet()), "/*");

        server.start();
        server.join();
    }
}

Luego lo que queda es agregar la clase PushServlet que se tiene que desplegar con el servicio de websockets, esta clase la podemos encontrar íntegra en el código de primefaces, yo he hecho un par de modificaciones para hacer las pruebas pero uds la pueden personalizar como gusten.

import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.websocket.WebSocket;
import org.eclipse.jetty.websocket.WebSocketServlet;

public class PushServlet extends WebSocketServlet {

    private static final long serialVersionUID = 1L;

    private final Map<String,Set> connectedClients = new ConcurrentHashMap>();

    @Override
    public void init() throws ServletException {
        super.init();
        String[] channels = {"chat","counter"};

        for(String channel : channels) {
            this.connectedClients.put(channel, new CopyOnWriteArraySet());
        }
    }

    @Override
    public WebSocket doWebSocketConnect(HttpServletRequest request, String protocol) {
        String channel = request.getRequestURI().split("/prime-push/")[1];
        System.out.println("Canal:"+channel);
        return new PrimeWebSocket(channel);
    }

    private class PrimeWebSocket implements WebSocket, WebSocket.OnTextMessage {
        Connection connection;
        String channel;

        public PrimeWebSocket(String channel) {
            this.channel = channel;
        }

        public void onClose(int closeCode, String message) {
            connectedClients.get(this.channel).remove(this);
        }

        public void onOpen(Connection connection) {
            this.connection = connection;
            connectedClients.get(this.channel).add(this);
        }

        public void onMessage(String message) {
            System.out.println(message);
            try {
                for(PrimeWebSocket ws : connectedClients.get(this.channel)) {
                    ws.connection.sendMessage(message);
                }
            }catch(IOException e) {
                System.out.println(e);
            }
        }
    }
}

Finalmente ejecutamos nuestro servidor Jetty el cual ya es un servidor de PUSH, este está corriendo en el puerto 8081, podemos hacer pruebas rápidamente a través de esta página http://websocket.org/echo.html donde tenemos un cliente de websockets.

Lo que debemos poner para probar es está ruta ws://localhost:8081/prime-push/counter y conectar, si nos aparece el mensaje conectado pues todo ha salido muy bien y el servidor está listo, podemos hacer pruebas con este enviando algo desde allí y abriendo esa página en más pestañas.

Cliente Primefaces – PrimePush

Para hacer la misma prueba desde un proyecto con primefaces debemos crear un proyecto web, descargar la librería de primefaces añadirla al proyecto que estamos creando y haremos lo siguiente:

Crearemos un archivo JSF con el nombre de index.xhtml y pondremos lo que se muestra a continuación.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:p="http://primefaces.org/ui" >
    <h:head>
        <title>Facelet Title</title>
        <style type="text/css">
            .display {
                font-size: 36px !important;
            }
        </style>

        <script type="text/javascript">
            //<![CDATA[
            function handleMessage(evt, data) {
                $('.display').html(data);
            }
            //]]>
        </script>
    </h:head>
    <h:body>
        <h:form>
            <h:outputText value="#{beanPush.count}" styleClass="ui-widget display" />

            <br />

            <p:commandButton value="Click" actionListener="#{beanPush.increment}" />
        </h:form>

        <p:push onmessage="handleMessage" channel="counter" />

    </h:body>
</html>

Luego crearemos una clase dentro de código que maneje la lógica de la aplicación en este caso un contador, este va ser nuestro manejador de bean.

package bean;

import java.io.Serializable;
import javax.faces.bean.ApplicationScoped;
import javax.faces.bean.ManagedBean;
import org.primefaces.context.RequestContext;

/**
 * @author christmo
 */
@ManagedBean
@ApplicationScoped
public class BeanPush implements Serializable {

    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public void increment() {
        count++;
        RequestContext.getCurrentInstance().push("counter", count);
    }
}

Finalmente necesitamos hacer que la aplicación apunte a nuestro servidor de Push creado anteriormente eso lo debemos hacer añadiendo lo siguiente dentro del archivo web.xml

    <context-param>
        <param-name>primefaces.PUSH_SERVER_URL</param-name>
        <param-value>ws://localhost:8081/</param-value>
    </context-param>

Y eso es todo espero que les funcione, si todo lo que escribí por aquí sonó a chino aquí les dejo los proyectos para que los revisen…

Proyectos 😉

Saludos

Christian Mora

@christmo

Anuncios
Categorías:glassfish, Java, JSF, Linux, NetBeans, Web 2.0 Etiquetas:

FLISOL Virtual 2011

marzo 29, 2011 1 comentario

Me he unido a unos amigos bloguers con la idea de formar La Comunidad Latinoamericana de Bloggers de Software Libre (CLABSOL), en ella se pretende a parte de compartir como comunidad distintos problemas y ayuda en distintos temas, difundir a todo el mundo virtual las ventajas de utilizar software libre de una forma que le puedan sacar el mayor provecho en sus actividades, para ello se ha planeado realizar este 9 de Abril el Festival Latinoamericano de Instalación de Software Libre más grande en Latinoamérica. Este año se desarrollará una versión Virtual del evento, el cual será emitido desde la plataforma Virtual 3D Second Life, así mismo por IRC y por Stream Multimedia.

El Installfest se dará inicio a partir de las 19:00 UTC con transmisión en vivo, sin embargo el canal de IRC y El entorno virtual 3D estarán abierto horas antes con diferentes tipos de entretenimientos.

Va ser un evento creado para dar a conocer las ventajas de utilizar software libre y discutir sobre algunos temas importantes que rondan este interesante mundo. La información relacionada al evento se encuentra disponible aquí http://flisol.info/FLISOL2011/flisolvirtual.

Flisol Virtual 2011

 

El stream (se activará en las siguientes horas):
El IRC:
– Servidor: irc.freenode.net
– Canal: #flisol-virtual

Aquí hay una imagen del lugar donde va ser este evento los esperamos allí para poder compartir conocimientos, percepciones y conceptos sobre el software libre y si te llama la atención este es el momento para que te unas y puedas aprender nuevas cosas.

Flisol virtual sitio

Nos vemos allí saludos…

Christian Mora
@christmo

Categorías:FLISOL, Linux, Software Libre

Android

febrero 22, 2011 1 comentario
Categorías:Android, Java, Linux, Software Libre

Academia Linux

marzo 30, 2010 3 comentarios

Aquí dejo unos cuantos archivos que les puede servir para obtener la certificación de IBM de administración de servidores linux.

Temario:

En estos documentos se cubre un área muy extensa, pero entre los temas principales tenemos:

  • Manejo básico de linux
  • Instalación y Configuración
  • Comando Básicos
  • Configuración de Servidores: Mail, DNS, DHCP, WEB, Samba, Apache, etc.
  • RAID
  • NFS
  • Backups
  • Configuración de Samba e impresoras compartidas.
  • Entre otras muchas cosas…

Bajar archivos aquí…

Saludos

christmo

Cambiar dirección MAC en linux

noviembre 23, 2009 2 comentarios

Hola retomando mi teclado he decidido poner este truquito que puede servirle a más de uno, lo encontre en el blog de un amigo y lo voy a replicar para no olvidarlo…

cambiar la mac de mi maquina encontré esta sencilla línea:

ifconfig <interfaz> hw <tipo de hardware> <dirección MAC>

Luego de esto es preferible reiniciar el servicio:

sudo /etc/init.d/networking restart

Para cambiar por defecto la dirección MAC ingresamos al directorio:

/etc/network/interfaces/ y en el archivo interfaces ubicamos una nueva línea:

MACADDR=<DIRMAC>

Este proceso hará que se cambie permanentemente nuestra MAC

Ahora si solo queremos cambiarla por un momento, o hasta que reiniciemos nuestro equipo lo podemos hacer fácilmente con un programas llamado macchanger:

#macchanger -m 00:11:22:33:44:55 eth0

Saludos

christmo

Categorías:Linux, Software Libre, Ubuntu

CRUD de usuarios en el servidor LDAP + JAVA

mayo 26, 2009 22 comentarios

En esta clase se va a realizar una clase completa para realizar una búsqueda, inserción, eliminación y modificación de los datos de los usuarios de un servidor LDAP desde el lenguaje de programación JAVA, al final de este post se pondrá el link para descargar el proyecto completo para que les quede como referencia de como es que yo lo hice, espero que les sirva, ojala puedan mejorar este código espero que lo compartan para poder ir aprendiendo todos…

import com.novell.ldap.LDAPAttribute;
import com.novell.ldap.LDAPAttributeSet;
import com.novell.ldap.LDAPConnection;
import com.novell.ldap.LDAPEntry;
import com.novell.ldap.LDAPException;
import com.novell.ldap.LDAPModification;
import com.novell.ldap.LDAPSearchResults;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
*/

public class CRUD {
     private Conexion conLDAP = new Conexion();
     private LDAPConnection lc = new LDAPConnection();
     
     /**
     * Metodo paraañadir un nuevo usuario, la persona que realice esta
     * transaccion debe tener los permisos para
     * @param strUIDManager
     * @param strPass
     */

     public void Añadir(String strUIDManager, String strPass) {
          try {
               LDAPEntry usuario = Datos();
               lc = conLDAP.ConexionManager(strUIDManager, strPass);
               lc.add(usuario);
               conLDAP.CerrarConLDAP(lc);
               System.out.println("Usuario
               Ingresado Correctamente...");
          } catch(LDAPException ex) {
               if (ex.getResultCode() == 68) {
                    System.err.println("ERROR:El Usuario ya se encuentra ingresado...");
               }
              Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
          }
     }

     /**
     * Datos del  usuario a ser Ingresado
     * @return LDAPEntry
     */

     public LDAPEntry Datos() {
          LDAPAttributeSet setAtr = new LDAPAttributeSet();
          setAtr.add(new LDAPAttribute("objectclass", new String("person")));
          setAtr.add(new LDAPAttribute("objectclass", new String("organizationalPerson")));
          setAtr.add(new LDAPAttribute("objectclass", new String("inetOrgPerson")));
          setAtr.add(new LDAPAttribute("objectclass", new String("posixAccount")));
          setAtr.add(new LDAPAttribute("objectclass", new String("top")));
          setAtr.add(new LDAPAttribute("userpassword", new String("newpassword")));
          //setAtr.add(new LDAPAttribute("uidnumber", new String("555")));
          setAtr.add(new LDAPAttribute("givenname", new String("Jim")));
          //setAtr.add(new LDAPAttribute("loginshell", new String("/dev/null")));
          //setAtr.add(new LDAPAttribute("gecos", new String("arroyo carvache carlos")));
          setAtr.add(new LDAPAttribute("gidNumber", new String("100")));
          setAtr.add(new LDAPAttribute("sn", new String("Smith")));
          setAtr.add(new LDAPAttribute("cn", new String("Jim Smith")));
          setAtr.add(new LDAPAttribute("mail", new String("JSmith@Acme.com")));
          //setAtr.add(new LDAPAttribute("homeDirectory", new String("/public/centros/carroyo")));
          setAtr.add(new LDAPAttribute("telephonenumber", new String("1 801 555 1212")));
          String dn = "uid=jsmith,ou=People,o=utpl,c=ec";
          LDAPEntry newEntry = new LDAPEntry(dn, setAtr);
          return newEntry;
     }

     /**
     * Metodo para buscar un usuario dentro del servidor LDAP
     * Filtro es el username a buscar
     * @param LDAPConnection lc
     * @param String strFiltro
     */

     public void Buscar(String strUser, String strPass, String strFiltro) {
          String filtro;
          LDAPSearchResults searchResults;
          String searchBase = "o=utpl,c=ec";
          int searchScope = LDAPConnection.SCOPE_SUB;
          filtro = "(uid=" + strFiltro + ")";
          try {
               lc = conLDAP.ConexionUser(strUser, strPass);
               searchResults = lc.search(searchBase, searchScope, filtro, null, false);
               //Recorre Todos los Usuarios de la Base
               while (searchResults.hasMore()) {
                    LDAPEntry nextEntry = null;
                    try {
                         nextEntry = searchResults.next();
                    } catch (LDAPException e) {
                         System.out.println("Error: " + e.toString());
                         continue;
                    }
                    LDAPAttributeSet attributeSet = nextEntry.getAttributeSet();
                    Iterator allAttributes = attributeSet.iterator();
                    //Recore los atributos del usuario
                    while (allAttributes.hasNext()) {
                         LDAPAttribute attribute = (LDAPAttribute) allAttributes.next();
                         String attributeName = attribute.getName();
                         Enumeration allValues = attribute.getStringValues();
                         if (allValues != null) {
                              while (allValues.hasMoreElements()) {
                                   String value = (String) allValues.nextElement();
                                   System.out.println(attributeName + ":  " + value);
                              }
                         }
                    }
                    System.err.println("------------------------------");
               }
               conLDAP.CerrarConLDAP(lc);
          } catch (LDAPException ex) {
               Logger.getLogger(Buscar.class.getName()).log(Level.SEVERE,null, ex);
          }
     }

     /**
     * Metodo Para Eliminar un usuario mandando como parametro el "uid"
     * @param strUser
     * @param strPass
     * @param strUIDEliminar
     */

     public void EliminarPorUID(String strUser, String strPass, String strUIDEliminar){
          String dn = "uid="+ strUIDEliminar + ",ou=People,o=utpl,c=ec";
          try {
               lc = conLDAP.ConexionManager(strUser, strPass);
               lc.delete(dn);
               System.out.println("\nEntry: " + dn + " Fue Eliminado Correctamente...");
               conLDAP.CerrarConLDAP(lc);
          } catch (LDAPException e) {
               if (e.getResultCode() == LDAPException.NO_SUCH_OBJECT) {
                    System.err.println("Error: NO existe ese usuario...");
               } else if (e.getResultCode() == LDAPException.INSUFFICIENT_ACCESS_RIGHTS) {
                    System.err.println("Error: NO tiene permisos suficientes para realizar esta transaccion...");
               } else {
                    System.err.println("Error: " + e.toString());
               }
          }
     }

     /**
     * Enviar Usuario a Modificar
     * @param strUser
     * @param strAtributo
     */

     public void Modificar(String strUser,String strAtributo) {
          try {
               LDAPAttribute atrubuto;
               lc = conLDAP.ConexionManager("Manager", "ibmlnx");
               atrubuto = new LDAPAttribute("mail", strAtributo);
               String dn = "uid="+strUser+",ou=People,o=utpl,c=ec";
               lc.modify(dn, new LDAPModification (LDAPModification.REPLACE, atrubuto));
               System.out.println("Atributo Modificado OK...");
          } catch (LDAPException ex) {
               if (ex.getResultCode() ==  LDAPException.INSUFFICIENT_ACCESS_RIGHTS) {
               System.err.println("Error: NO tiene permisos suficientes para realizar esta transaccion...");
               }
          }
     }

     public boolean ValidarPassWord(String strUser, String strPass) {
          boolean correct = false;
          String dnc = "uid=+" + strUser + ",ou=People,o=utpl,c=ec";
          try {
               lc.bind(LDAPConnection.LDAP_V3, dnc, strPass.getBytes("UTF8"));
               LDAPAttribute attr = new LDAPAttribute("userPassword", strPass);
               correct = lc.compare(dnc, attr);
               System.err.println(correct ? "El Password es correcto" : "El Password NO es correcto.\n");
          } catch (LDAPException ex) {
               Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
          } catch (UnsupportedEncodingException ex) {
               Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
          }
          return correct;
     }
}

Vea también:

Conexión al servidor LDAP desde JAVA

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA – Netbeans

Categorías:Java, ldap, Linux Etiquetas: , ,

Busqueda de Usuarios en el Servidor LDAP + JAVA

mayo 26, 2009 5 comentarios

Continuando con el ejemplo anterior, una ves realizada la conexión en el servidor LDAP, desde nuestra clase java, vamos a probar una clase que nos permita realizar búsquedas de usuarios ingresados en este servidor.

Esta clase seria así:


package conexionldap;
import com.novell.ldap.*;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
* Clase para Buscar Usuarios el Filtro es el usuario que se desea buscar.
*/

public class Buscar {

     private String searchBase = "o=utpl,c=ec";
     private int searchScope = LDAPConnection.SCOPE_SUB;
     private String filtro;
     private LDAPSearchResults searchResults;

     /**
     * Metodo para buscar un usuario dentro del servidor LDAP
     * @param LDAPConnection lc
     * @param String strFiltro
     */

     public Buscar(LDAPConnection lc, String strFiltro) {
          filtro = "(uid="+ strFiltro + ")";
          try {
               searchResults = lc.search(searchBase, searchScope, filtro, null, false);
               //Recorre Todos los Usuarios de la Base
               while (searchResults.hasMore()) {
                    LDAPEntry nextEntry = null;
                    try {
                         nextEntry = searchResults.next();
                    } catch (LDAPException e) {
                         System.out.println("Error: " + e.toString());
                         continue;
                    }
                    LDAPAttributeSet attributeSet = nextEntry.getAttributeSet();
                    Iterator allAttributes = attributeSet.iterator();
                    //Recore los atributos del usuario
                    while (allAttributes.hasNext()) {
                         LDAPAttribute attribute = (LDAPAttribute) allAttributes.next();
                         String attributeName = attribute.getName();
                         Enumeration allValues = attribute.getStringValues();
                         if (allValues != null) {
                              while (allValues.hasMoreElements()) {
                                   String value = (String) allValues.nextElement();
                                   System.out.println(attributeName + ":  " + value);
                              }
                         }
                    }
                    System.out.println("------------------------------");
                    lc.disconnect();
               }
          } catch (LDAPException ex) {
               Logger.getLogger(Buscar.class.getName()).log(Level.SEVERE,null, ex);
          }
     }
}

Vea también:

Conexión al servidor LDAP desde JAVA

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA – Netbeans

Categorías:Java, ldap, Linux Etiquetas: , ,