Todas las entradas de: Juanjo Montiel

Cómo mantener procesos en segundo plano entre distintas sesiones de terminal en Linux

¡Hola!

Para comenzar el año, os vengo con un post que no es realmente de programación, sino más bien de administrador de servidores… Pero como últimamente le doy a todo, me ha parecido interesante escribirlo 🙂

El otro día me surgió la necesidad de copiar casi un tera de información entre dos discos duros remotos. ¿cómo hacerlo? Utilizando el comando scp en modo recursivo.

Sin embargo, incluso utilizando el & para dejar el proceso en segundo plano, al desconectarme de forma accidental (se fue la luz en casa), el proceso se paró y tuve que volver a reanudar la copia.

¿Cómo solucionarlo? Existe una herramienta en Linux llamada Tmux. Esta herramienta, nos permite ejecutar varios terminales desde un solo terminal, y movernos entre ellos de forma sencilla. Y lo más interesante, es que podemos dejar un terminal ejecutando procesos, separarnos de él, cerrar nuestra sesión, volver a ella y continuar la sesión, manteniendo los trabajos, el historial del bash, la consola escrita, ETC.
En palabras del propio readme, tmux es:

tmux is a “terminal multiplexer”, it enables a number of terminals (or windows)
to be accessed and controlled from a single terminal.

tmux es un “multiplexor de terminales” que permite acceder y controlar varios terminales (o ventanas) desde una sola terminal.

Y ahora, lo más interesante: ¿cómo funciona?

  1. Antes de nada, lo instalamos:
    • Desde distribuciones basadas en Debian: aptitude install tmux
    • Desde distribuciones basadas en red hat: yum install tmux

    Si tienes otra distribución, puedes intentar encontrarla con tu gestor de paquetes, o compilarla desde el código fuente usando su repositorio git en: https://github.com/tmux/tmux.

  2. Desde una terminal, creamos una sesión escribiendo simplemente: “tmux”
  3. Ejecutamos los comandos que queramos.
  4. Una vez queramos salir de la sesión sin terminarla, escribiremos: “tmux dettach
  5. Cuando queramos retomar la sesión, miramos la lista de sesiones activas con: “tmux list-sessions”, y nos conectamos al número mostrado al principio de cada sesión, con: “tmux attach -t num, por ejemplo: tmux attach -t 0.

Aquí os pongo un ejemplo de consola para que lo veáis en acción:

root@koala [~]# tmux
root@koala [~]# pwd
/root
root@koala [~]# tar -zcf /tmp/borrar.tar.gz ./* &
[1] 6116
root@koala [~]#
root@koala [~]# tmux detach
[detached]
root@koala [~]# exit
logout
Connection to koala.tuhorizonte.es closed.
C:\Users\juanjo> 

C:\Users\juanjo>ssh root@koala.tuhorizonte.es
root@koala.tuhorizonte.es's password:
Last login: Fri Jan  1 22:46:39 2016 from xxx.xxx.xxx
root@koala [~]#root@koala [~]# tmux list-sessions
0: 1 windows (created Fri Jan  1 22:49:20 2016) [80x24] 
root@koala [~]# tmux attach -t 0
root@koala [~]# 
[1]+  Done                    tar -zcf /tmp/borrar.tar.gz ./*
root@koala [~]# cd /tmp
root@koala [/tmp]# ls -lh borrar.tar.gz
-rw-r--r--. 1 root root 4.9M Jan  1 22:49 borrar.tar.gz
root@koala [/tmp]# rm borrar.tar.gz
rm: remove regular file `borrar.tar.gz'? y
root@koala [/tmp]# exit
[exited]
root@koala [~]# exit
logout
Connection to koala.tuhorizonte.es closed. 

Para más información sobre el programa, podéis leer su manual en man tmux

¡Saludos y buen año a todos!

Entrada visitada 474 veces

ValidationSummary accesible en MVC 5

¡Hola!

Hoy os vengo con un truquillo que, en caso de estar desarrollando webs accesibles en MVC, os puede venir bien.

Una de las cosas que considero muy importantes a la hora de mostrar una lista de errores de cumplimentación de formularios, es encabezar la misma con una cabecera, de modo que el usuario de lector de pantallas, al navegar por la lista de encabezados, dé con el resumen de los errores de formulario de forma fácil. Si obviamos esta cabecera, es posible que esa lista pase desapercibida, o al menos es lo que me dice la experiencia 🙂

En MVC 4, hasta donde recuerdo, no existía la sobrecarga de ValidationSummaryFor que os muestro a continuación, y que sí está disponible en MVC 5:

@Html.ValidationSummary("Revisa los siguientes errores", new { @class = "text-danger" }, "h3")

Esta extensión de HtmlHelper pinta una lista de errores, añadiéndole la clase text-danger (estoy usando bootstrap), y encabezando la lista con una etiqueta “h3” que encerrará el mensaje pasado en el primer parámetro.

¿La única pega de todo esto? Que el encabezado con el mensaje se ve siempre aunque no haya errores 🙁 .
Sin embargo, este método pinta una clase por defecto cuando el formulario es válido: “validation-summary-valid”; así que con un poco de magia CSS, podemos añadir lo siguiente a nuestra hoja de estilos:

/* para ocultar los encabezados de los validation summary si son válidos */
.validation-summary-valid {
	display: none;
}

¿Más fácil? ¡Imposible!

Y ahora ya, como truquillo de nota, podríamos hacer una pequeña mejora a la experiencia del usuario, añadiendo, mediante jquery, una función que ponga el foco en la lista de errores cuando esta esté visible. Así, un usuario de lector de pantallas, escuchará el encabezado con el mensaje que hayamos puesto, y será consciente al instante de que algo pasa con ese formulario.
Añadamos este script a nuestro sitio (recordad que necesitaréis jquery):

$(function () {
	var encabezado = $(".validation-summary-errors:last :header");
	if (encabezado.length) {
		encabezado.attr("tabindex", "-1");
		encabezado.focus();
	}
});

¡

Et Voilà!

¿Qué estamos haciendo aquí?

  1. Adjuntándonos al evento onDocumentReady, para que esto se ejecute cuando la página esté cargada.
  2. Buscando el último elemento con la clase validation-summary-error, y dentro de él, cualquier encabezado, sea del nivel que sea.
  3. Si lo encuentra, le pone tabIndex a -1 para poder focalizar en él de forma programática.
  4. Y por último, fuerza el foco a ese encabezado.

A mí personalmente me gusta crear un bundle de scripts de accesibilidad, y meter en él pequeños ficheros, cada uno de los cuales realiza una acción concreta. Así tengo la sensación de que mi código es más fácil de mantener.

¡Espero que os sirva!

¡A disfrutar picando! 😉

Entrada visitada 551 veces

Evitar interacciones no deseadas al ocultar elementos con animación en jQuery

¡Hola!

Esta mini entrada surge por un problema que estaba teniendo con unas animaciones en jQuery.

Resulta que estoy mostrando y ocultando una lista de enlaces usando fadeIn, fadeOut, slideDown y slideUp, dándole un tiempo de animación tanto en mostrar como en ocultar. ¡Estas cosas que a los que veis os molan tanto, que eso de que aparezcan y desaparezcan elementos de la pantalla así de golpe como que no os mola! 😉
Pues resulta que me di cuenta de algo obvio pero que no se me había ocurrido: Durante una animación de desaparición (por deslizamiento o por transparencia), el usuario de lector de pantallas puede seguir interactuando con los elementos, sin darse cuenta de que esos elementos están desapareciendo.
Y como a mí me la traen al fresco las animaciones y las desapariciones progresivas, se me ocurrió usar, durante las desapariciones, un atributo que oculta elementos para lectores de pantalla. Este atributo, dentro de las recomendaciones ARIA de la w3c, es “aria-hidden“, que ajustado a true, oculta la etiqueta en la que se aplique a lectores de pantalla.

Así que, podríamos usar el siguiente código para ocultar un ul durante 400 milisegundos, pero que desde el primer momento ya no se muestre a lectores de pantalla aunque tarde un rato en desaparecer:

lista.attr("aria-hidden", "true").slideUp(200, function () { $(this).removeAttr("aria-hidden"); });

¿Qué estamos haciendo?

  1. Ocultamos el elemento a lectores de pantalla.
  2. Lanzamos la animación de desaparición.
  3. Cuando se completa la animación, volvemos a mostrar el elemento a lectores de pantalla, pues como ya está oculto con display:none, no será visible para nadie. Vuelvo a quitar el aria-hidden, ya que si luego queremos volver a mostrar el elemento, los lectores no lo verán si esa propiedad se ha quedado a true :).

¡Mucho cuidado con aria-hidden y display:none! Si un elemento tiene display:none pero aria-hidden está a false explícitamente (no que no esté el atributo, sino puesto a false), el elemento será mostrado a lectores de pantalla pese al display:none. ¡Flipante!

¡Espero que este truquillo os pueda servir!

¡Buena semana!

Entrada visitada 374 veces

Tecla rápida para salir de escritorio remoto sin desconectarnos de él

¡Hola!

Hoy vengo con una entrada muy corta, pero que creo podrá servir a más de uno.

Cuando trabajamos con escritorio remoto, una vez estamos en la ventana y con pantalla completa, las combinaciones de teclas se ejecutan en el servidor)… Así que, ¿cómo podemos volver a nuestra máquina sin desconectarnos?
Con ratón sé que hay una forma que desconozco, pero para usuarios de lectores de pantalla que usamos el teclado… podemos usar la combinación de teclas control + alt + pause. Esto desactiva la pantalla completa, y podremos pulsar alt + tab para cambiar a la ventana anterior, y así volver a nuestra máquina.
Cuando queramos volver al escritorio remoto y a ejecutar comandos en él, deberemos situarnos otra vez en la ventana de dicho escritorio, y volver a pulsar control + alt + pause.

¡Espero que os sirva!

¡Saludos!

Entrada visitada 5041 veces

Los captchas y el concepto de discapacidad

  • ¿Qué es una persona con discapacidad? – le pregunté.
  • Pues… una persona que tenga una discapacidad, ¿no? es decir: un sordo, un ciego, un tetrapléjico.
  • ¿Y tú?
  • ¿Yo qué?
  • ¿Tú eres discapacitado?
  • No no, claro, yo no, yo no tengo ninguna discapacidad, gracias a dios.
  • ¿Y yo?
  • ¿Tú? ¿Esta pregunta tiene trampa?
  • No hombre, no.
  • Pues… pues claro, ostias, eres ciego.
  • Ajam…

    Imagina que aquí tienes un formulario. Pongamos que el formulario es largo, de cuarenta campos. Te has pasado más de cinco minutos rellenando el dichoso formulario, pero no te importa, porque en cuanto le des a enviar, te habrás registrado en una página maravillosa a la que tenías muchas ganas de acceder.

    Ahora imagína que, antes de enviar el formulario, tienes que resolver un captcha. Pero ¡vaya! no es un captcha en el que tienes que descifrar una imagen, sino que se trata de un captcha musical.

    Pulsa en el botón “Reproducir”, escucha las notas, y escríbelas en el cuadro de edición. El 1 es el do, el 2 el re, y así hasta el siete, que es el si. Así, si las notas son re, mi, fa, sol, la si, tendrás que pulsar en el teclado: 234567.


Pulsa las notas usando los botones, si lo prefieres:

Notas que has pulsado:


    Vista no, pero buen oído tengo, afortunadamente; y gracias a mis años de conservatorio, muy entrenado para detectar las notas musicales. Te puedo resolver este captcha con un 95% de aciertos.
    ¿Que no? En esta demo te lo demuestro:< ¿Y tú? ¿Eres capaz?... ¿no?... ¡vaya! ¡Y luego dicen que yo soy el discapacitado! 😉 Y ahora, pregúntate: ¿es justo que alguien ponga este captcha en una página web?
    ¿No? ¿Por qué?
    Pues evidentemente, porque no todas las personas tienen formación musical y buen oído. Así que tampoco es justo que me pongas un captcha con imagen, porque no puedo verla. Al menos tú puedes entrenar la oreja 😉

    Así que cuando tengas que desarrollar tu próximo sitio, piensa en cuántas personas con capacidades diferentes podrán entrar a tu web: personas que ven bien, personas que usan gafas, personas que no ven, personas que no escuchan, personas que no pueden usar el teclado o personas que no pueden usar el ratón, personas expertas en informática, personas menos expertas… ¡el abanico es amplísimo!

    ¿Que es imposible tener en cuenta a todo el mundo? ¡Claro! Pero hay que intentarlo, ¿no? las propias siglas de la www te lo están pidiendo: world wide web: la web a lo ancho del mundo… Y mira que hay personas distintas en el mundo!

    Entrada visitada 2204 veces

    WCF. Usar excepciones nativas de .net en lugar de FaultException

    ¡Hola!

    Para estrenar este blog, vengo con una entrada en la que os hablo de WCF, y de cómo propagar errores como Exception en lugar de usar FaultException.

    ¿Para qué puede servir esto?

    Básicamente, en mi caso lo necesitaba para poder transmitir más información de la que por defecto FaultException transmite a la hora de lanzar un error.

    Inconvenientes: Solo funcionará si tanto el servidor como el cliente están usando .net, pues esto por debajo usa Soap por interoperabilidad, pero al serializar exceptions, vamos a usar el NetDataContractSerializer; así que, ¡adiós a la interoperabilidad! 🙁

    ¿Ventajas? Si estamos trabajando con .net, podemos hacer cosas tan sencillas como:

    try
    {
        proxyCliente.RealizaOperacion();
    }
    catch (EntityException ex)
    {
        // ...
    }
    catch (Exception exGeneral)
    {
        // ...
    

    Así, en nuestro error, podremos ver toda la información que el servidor posee sobre el mismo.

    El artículo original es muy largo y está en inglés. Aquí os incluyo un adjunto como ejemplo para que veáis esto en código. Está compilado en Visual Studio 2010 (el original era de 2008), y queda bastante claro el ejemplo. De todas formas, aquí os dejo el artículo original en inglés.

    ¡Que os sirva! 🙂

    WcfExtensions.zip

    Entrada visitada 876 veces

    Presentación

    – ¡Hola a todos!
    – Soy Juanjo Montiel, y soy programador.

    (coro de voces salmodiando) – ¡Hola, Juanjo!

    Esta es mi primera entrada en este blog, aunque ya publico cosillas en Mi blog personal, en el que escribo un poco de todo.

    Soy programador, actualmente trabajando en “Grupo ICA” Barcelona. Me dedico mayoritariamente al desarrollo en .NET con c#, y me apasiona la programación. Soy una de esas personas que puede decir, sabiendo que tengo mucha suerte, que me encanta mi trabajo :).

    Además de la programación, me apasionan la música (toco el piano desde hace ni sé cuántos años), y la lectura, sobre todo libros de ciencia ficción, aunque también soy adicto a otras substancias como a la novela policíaca, terror, intriga…. En retrospectiva, prueba de mi pasión por la literatura es que programo mucho software orientado a ella: Litersoft, Daisy converter, Cuentaminados… ¡Arg, soy monotemático!

    Me he decidido a iniciar este blog, ya que muchas veces me apetece publicar temas de programación, pero siento que en el blog personal no acaba de encajar; así que aquí me tenéis.

    ¿Qué encontraréis aquí?

    Todo lo que se me ocurra, orientado al desarrollo, la accesibilidad, y cualquier fricada informática que tenga algo que ver con el mundo del software. Publicaré artículos sobre programación (casi siempre en .NET, que es el lenguaje en el que programo con más frecuencia), códigos para ayudar en la accesibilidad, buenas prácticas, curiosidades, programillas que vaya haciendo en mi tiempo libre… Un poco de todo.

    En este blog os encontraréis muchas referencias a teclas rápidas, y lo siento, pero veréis muy pocas capturas de pantalla. Soy ciego, y mi trabajo lo realizo 100% con teclado. ¡En algún momento publicaré algunos artículos sobre atajos de teclado en Visual Studio, y veréis cómo aumenta vuestra productividad! 😉

    Si queréis conocerme más a nivel profesional, podéis Ver aquí mi currículum

    Y sin más, que tampoco me quiero enrollar, ¡entremos en materia!

    ¡Gracias por leerme!

    Entrada visitada 344 veces