Mensajes

Hola chicos. Perdonar por el retraso al contestar.
He estado probando con distintos patrones de diseño y el resultado final es que depende del entorno de trabajo o necesidades, no son muy viables.

En el ejemplo que nos ocupa, tengo un servidor de Syslog. El caso es que cuando al servidor le llegan pocos eventos de otros hosts, no hay problemas y procesa todos los mensajes, pero cuando el número de mensajes recibidos aumenta, no es capaz de recoger todos haciendo uso del patrón Pool.

Creo que se vuelve muy pesado el chequeo del Pool, y los paquetes UDP llegan al máximo de tiempo dando un TIMEOUT en el Listener.

No se que opináis, pero personalmente no veo opción mediante patrones para reutilización de objetos en este caso.

Ok. Voy a revisarlo. Gracias por responder.

[El servicio que escucha "Listener" y ejecuta el parseo de datos en un nuevo hilo llamando a "Parser" desde el pool.]

Hola gente. Después de leerme e intentar comprender el patrón "Object Pool", este es el resultado.

El servicio que escucha "Listener" y ejecuta el parseo de datos en un nuevo hilo llamando a "Parser" desde el pool.

public class Listener implements Runnable {

    private boolean serviceRun;
    private DatagramSocket socket;
    private SysLogParser parser;
    private DatagramPacket data;
    private Thread runThread;
    private int bufferSize;

    private void init() {
        bufferSize = 2048;
        setServiceRun(true);
    }

    @Override
    public void run() {
        init();
        try {
            System.out.println("Servicio iniciado\n");
            data = new DatagramPacket(new byte[bufferSize], bufferSize);
            socket = new DatagramSocket(10100);
            while (isServiceRun()) {
                try {
                    socket.receive(data);
                    parser = ListenerPool.getInstance().checkOut(data.getData());
                    parser.start();
                } catch (IOException e) {
                    System.out.println("Error Listener: " + e.getMessage());
                }
            }
        } catch (Exception e) {
            System.out.println("Error Listener2: " + e.getMessage());
        }
    }

    public boolean isServiceRun() {
        return serviceRun;
    }

    private void setServiceRun(boolean serviceRun) {
        this.serviceRun = serviceRun;
    }
   
    public void start(){
        if (runThread == null){
            runThread = new Thread(this);
            runThread.start();

        }
    }
   
    public void stop(){
        if (runThread != null){
            setServiceRun(false);
        }
    }
}

La clase que gestiona el pool "ListenerPool" para la clase "Parser"

public class ListenerPool {

    private static ListenerPool instance = new ListenerPool();
    private long expirationTime;
    private HashMap<Parser, Long> locked, unlocked;

    private ListenerPool() {
        expirationTime = 5000;
        locked = new HashMap<Parser, Long>();
        unlocked = new HashMap<Parser, Long>();
    }

    public static ListenerPool getInstance() {
        createInstance();
        return instance;
    }

    private static void createInstance() {
        if (instance == null) {
            synchronized(ListenerPool.class) {
                if (instance == null) {
                    instance = new ListenerPool();
                }
            }
        }
    }
   
    protected Parser create(byte[] data) {
        return new Parser(data);
    }

    public boolean validate(Parser o) {
        return true;
    }
   
    public synchronized Parser checkOut(byte[] data) {
        long now = System.currentTimeMillis();
        Parser t;
        if (unlocked.size() > 0) {
            Iterator it = unlocked.keySet().iterator();
            while (it.hasNext()) {
                t = (Parser) it.next();
                if ((now - unlocked.get(t)) > expirationTime) {
                    unlocked.remove(t);
                    expire(t);
                    t = null;
                } else {
                    if (validate(t)) {
                        unlocked.remove(t);
                        locked.put(t, now);
                        return (t);
                    } else {
                        unlocked.remove(t);
                        expire(t);
                        t = null;
                    }
                }
            }
        }
        t = create(data);
        locked.put(t, now);
        return (t);
    }

    public synchronized void checkIn(Parser t) {
        locked.remove(t);
        unlocked.put(t, System.currentTimeMillis());
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
       throw new CloneNotSupportedException();
    }
}

El parseador de datos "Parser"

public class Parser implements Runnable {

    private byte[] data;
    private Thread runThread;

    public Parser(byte[] data) {
        this.data = data;
    }

    private void show(){
        System.out.println(runThread.getId() + "@" + runThread.getName());
    }

    @Override
    public void run() {
        this.showLog();
        SysLogParserPool.getInstance().checkIn(this);
    }
   
    public void start(){
        if (runThread == null){
            runThread = new Thread(this);
            runThread.start();
        }
    }
}

Si os fijáis en la salida que nos da el método show() de "Parser". ¿No debería de manear hilos con el mismo nombre? Se están creando nuevos hilos de la clase Parser, cuando deberían tener el mismo nombre, ¿no?


Salida

11@Thread-1
12@Thread-2
13@Thread-3
14@Thread-4
15@Thread-5
16@Thread-6
17@Thread-7
18@Thread-8
etc....

Gracias por vuestras respuestas.

La idea es optimizar el uso de recursos en un servicio que está a la escucha de conexiones, sobre todo cuando lleva mucho tiempo activo.

He leído lo que me ponían 'adastra' y 'egyware'. Con ello he encontrado nuevo mundo, jejeje, los patrones de diseño. Estoy estudiando distintos patrones para ver cual se adapta mejor a lo que busco.

En cuanto lo tenga funcionando os lo pongo.

Mil gracias...

Muchas gracias. Voy a estudiar lo que me decís.
Un saludo.

Hola gente.

Estoy jugando con el protocolo SNMP utilizando SNMP4J. Por ejemplo a la hora de crear un receptor de Traps, me llama la atención que ya viene preparado para definir cuantos hilos queremos ejecutar simultaneos cuando dicho servicio una vez iniciado , mediante la clase 'TheadPool'.

http://www.snmp4j.org/doc/org/snmp4j/util/ThreadPool.html

He intentado realizar lo mismo para otros servicios que he desarrollado siguiendo el código de dicha clase y demás, pero se me está complicando.
¿A alguien se le ocurre un forma de definir de una forma sencilla cuantos hilos puede por ejemplo ejecutar un ServerSocket como máximo?

Muchas gracias.

Hola gente.

Estoy realizando una prueba de concepto explotando la vulnerabilidad Java/Exploit.CVE-2012-4681, y estoy un poco bloqueado.

Tengo creada una aplicación que desempaqueta JSPs embedidos en el JAR y los sirve mediante JETTY, que también está embedido enedicho JAR. Uso una remote shell y demás...

La cosa es:
¿Es posible embeber la máquina virtual de java? o en su defecto ¿que archivos son necesarios extrictamente de la carpeta jreX de instalación, para que la máquina virtual funcione?

No he encontrado referencia alguna al respecto, y probando manualmente a borrar archivos me estoy eternizando.
Por cierto, no se si se escribe "Embeber" pero eso pone la Real academia Española.  >:-)

Hola.

Me gustaría saber si alguien dispone de algo de información acerca de optimización de imágenes. Trato de hacer mi propio gestor documental en java, y no me he quedado un poco tirao en este punto.

Gracias 

Que mejor que el nativo para Windows 7 junto a Security Essentials.

http://windows.microsoft.com/es-ES/windows/products/security-essentials

No se hasta que punto  pueden mejorar otros productos de terceros estas soluciones, pero recomiendo a la gente eliminar todas las reglas que trae por defecto el FW de windows y jugar con sus posibilidades.

Otra opción que yo usé mucho tiempo es correr FreeBSD con distros del tipo PfSense, Mon0wall, BrazilFW, sobre máquinas virtuales y mediante switchs virtuales salir a traves de ellos. Es muy sencillo de configurar y a parte de ser "free" se coge mucha experiencia en seguridad perimetral y entornos FW o UTMs.

Está bien tener un buen soft de FW pero nada mejor que trabajar directamente sobre L2 o capa IP si de seguridad hablamos, por eso yo descarto simpre los Firewall en capa aplicación, ya que es de sobra demostrado lo vulnerables que son y lo ineficaz que resulta en algunos su heuristica o sistemas de defensa proactiva. Mismamente ayer estuve viendo una charla de hace tiempo del "Sr Maligo" en la que explota a través de HTTP una conocida vulnerabilidad sobre IE8, que en VirusTotal canta en más de 16 antivirus y Kaspersky ni se entera de la shell.

Todo mi máximo respetao al soft, pero  ... Lo mejor un buen Appliance, o algo del tipo PfSense+Snort+Clamv, o directamente te calzas cada 180 días un buen TMG.

Hey, muchas gracias...

Ya tengo para quemar horas al sol...