Jueves 22 de junio de 2017

Y sigue avanzando…

Hoy comentaré dos cosas. La primera es el estado del libro sobre LyX y la segunda… bueno, primero lo primero, así te doy, estimado lector, la posibilidad de saltarte la segunda parte 😆 El estado del libro ¡Aquí lo vemos! El contenido está, básicamente, listo. Respecto de lo que comenté en el último reporte se […]
Asociación LiGNUx: Llega Opus 1.2, la popular biblioteca de audio se renueva

Sega Forever, disfruta de los juegos de Sega gratis en Android

Hoy os traemos una de las mejores noticias que os podemos dar en el mundo de los smartphones y en concreto de los que vienen con nuestro sistema operativo favorito, Android.  Los juegos se están convirtiendo cada vez más en un indispensable, no sólo en consola tradicional sino también en nuestros smartphones. Es por eso que la oferta de videojuegos en móvil cada vez está más interesante
Baltasar Ortega

Baltasar Ortega
KDE Blog

Plasma 5.10 y Akademy 2017 de Almería vigésimo podcast de KDE España

Sexto mes y sexto podcast. Llegamos al ecuador del año y lo hacemos con un pleno de regularidad en cuanto a material audiovisual. Me complace en presentar Plasma 5.10 y Akademy 2017 de Almería vigésimo podcast de KDE España que fue grabado el pasado 20 de junio. Espero que sea de vuestro agrado.

Plasma 5.10 y Akademy 2017 de Almería vigésimo podcast de KDE España

El sexto de vídeo poscast de la tercera temporada de KDE España titulado Plasma 5.10 y Akademy 2017 de Almería fue grabado una tarde calurosa y retransmitido en directo para todo el mundo que quisiera hacerlo.

Plasma 5.10 y Akademy 2017 de Almería

Los participantes del vigéismo vídeo podcast fueron:

  • Ruben Gómez Antolí, miembro de KDE España y que siguió realizando las labores de presentador.
  • Aleix Pol @AleixPol, ex-presidente de  http://www.kde-espana.org/ y vicepresidente de KDE e.V.
  • Albert Astals @tsdgeos ex-presidente deKDE España

A lo largo de casi la hora y veinte que duró el vídeo podcast se habló de todo lo relacionado con dos eventos muy importantes para la Comunidad KDE: el lanzamiento y las nuevas funcionalidades del escritorio más moderno que ofrecen, es decir, Plasma 5.10 y el evento que todo el mundo relacionado con el mundo KDE espera con impaciencia, Akademy y Akademy-es (su versión española).


Además, gracias al trabajo de VictorHck (no os perdáis su blog) pronto estará disponible el podcast en archive.org.

Plasma 5.10 y Akademy 2017 de Almería

Espero que os haya gustado, si es así ya sabéis: “Manita arriba“, compartid y no olvidéis visitar y suscribiros al canal de Youtube de KDE España.

Como siempre, esperamos vuestros comentarios que os aseguro que son muy valiosos para los desarrolladores, aunque sean críticas constructivas (las otras nunca son buenas para nadie). Así mismo, también nos gustaría saber los temas sobre los que gustaría que hablásemos en los próximos podcast.

Aprovecho la ocasión para invitaros a suscribiros al canal de Ivoox de los podcast de KDE España que pronto estará al día.

Miércoles 21 de junio de 2017

Asociación LiGNUx: Añade paletas de colores a GIMP o Inkscape gracías a ajEsuSdA Color Palettes
Baltasar Ortega

Baltasar Ortega
KDE Blog

5 Trucos para ganar dinero como programador para KDE

Aunque KDE Blog es un blog personal, siempre está abierto a colaboraciones de terceras personas. Este es el caso de este nuevo artículo de la escritora Edith Gómez, editora en Gananci, apasionada del marketing digital, especializada en comunicación online y que se está convirtiendo en una habitual del blog. En esta ocasión nos presenta “5 Trucos para ganar dinero como programador para KDE” que evidentemente

5 Trucos para ganar dinero como programador para KDE

Si te estas preguntando qué es KDE, entonces es porque no eres aun un programador con experiencia en este mundo. KDE se refiere a una comunidad de personas que crean software libre para otras personas.

Pero si este es el caso, ¿cómo se gana dinero cuando el punto es crear software gratuito? Esta es una buena pregunta. Hay varias formas de recaudar dinero siendo programador KDE, pero lo importante es saber como usar estas herramientas y hacer el mejor esfuerzo para recaudar dinero.

No todos en el mundo KDE es programador, además hay diseñadores, traductores, promotores, y más. Todas estas personas se unen y trabajan juntas para crear software y dispositivos funcionales y modernos. Si eres uno de ellos y quieres empezar tu negocio, entonces debes saber como hacerte valioso.

Teniendo esto en cuenta, si quieres ganar dinero como parte de la comunidad KDE, sigue estos trucos:

1. Conviértete en freelancer: si ya llevas tiempo creando sitios web, haciendo script, diseñando páginas web, entonces ofrecer tus servicios independientes parece simple. Sin embargo, en el mundo de los freelancers, debes trabajar duro y dejar una buena impresión en tus clientes.

Asegúrate de dejar saber en tu comunidad KDE que estás trabajando aparte, tal vez alguien necesite tu ayuda. También únete a sitios como freelancer donde puedes publicar tus servicios y recibir ofertas. Y si te gustan las redes sociales, no hay nada malo en crear una página para tus servicios, o utilizar LinkedIn para ofrecer tus servicios.

2. Venta de anuncios: es verdad, se puede vender publicidad online. Sin embargo, necesitas tener una página web y generar tráfico. Algunas veces con solo crear una buena estrategia SEO, u ofreciendo algo gratis, generas suficiente tráfico.

Puedes ofrecer información interesante y promocionarla en tus comunidades, siempre y cuando ellos hagan clic en tus anuncios, ganarás dinero.

3. Programador web: ya tienes experiencia creando sitios web, entonces, ¿por qué no ofrecer tus servicios? Esta es una de las formas maas rentables de ganar dinero, pues puedes hacer una buena reputación y ser recomendado por miembros de tu comunidad.

Si no quieres usar todo tu tiempo en crear sitios web nuevos, puedes optar por comprar una página web vieja, renovarla, y venderla por más dinero.

 

4. Vende tu propio programa o producto: cuando eres un buen programador seguro que tienes ciertos producto para vender. Necesitas lanzar el producto, darlo a conocer, y promocionarlo.

Puedes unirte a otro programador o freelancer para que te ayude a darle los últimos detalles a tu producto y te ayude a calcular su precio y venderlo después.

5. Donaciones: esta es la forma más común de recaudar dinero en el mundo KDE. Pero así como es común, también es difícil de predecir, pues no todo el mundo está dispuesto a donar.

De todas formas, el mundo KDE funciona así. Una de las mejores formas para promover donaciones, es crear templates gratuitos que sean interesantes para las personas, así cuando los liberes al mundo, tendrás muchas visitas y donaciones porque las personas querrán más de tus productos.

Cuando ganes más tráfico, podrás también crear un sistema de afiliados o de publicidad y ganar aún más dinero. Los programadores tienden a crear script y template por montones, por lo que no hay límites y podrás seguir atrayendo visitantes.

Como puedes ver, ganar dinero como programador es algo de trabajo, pero no es imposible. Si estás dispuesto a trabajar duro con estos trucos, puedes ganar algo de ingresos extras sin necesidad de dejar de hacer lo que más te gusta: crear software libre.

Estas opciones son especialmente recomendables para aquellos que son nuevos en la industria o que buscan crear su propio negocio. No es necesario tener un trabajo a tiempo completo si sabes buscar dinero en otros lugares.

Martes 20 de junio de 2017

Asociación LiGNUx: Próximamente…
Baltasar Ortega

Baltasar Ortega
KDE Blog

Ttrss pocket, tu lector de rss y pocket en tu escritorio Plasma – Plasmoides de KDE (77)

Hace un tiempo presenté RSS Indicator, un lector de rss para nuestro escritorio Plasma que nos puede ayudar para seguir con atención algunas de las webs que más nos interesan. La Comunidad KDE no se contenta con tener una alternativa y hoy me complace presentar dentro de la serie de Plasmoides de KDE, Ttrss pocket, tu lector de rss y pocket en tu escritorio Plasma que seguro que convence a más de uno.

Ttrss pocket, otro lector de rss en tu escritorio Plasma – Plasmoides de KDE (77)

De la mano de Kinta os presento ttrss pocket, un lector de noticias vía rss y pocket especialmente diseñado para ser utilizado a pantalla completa en un dispositivo táctil, aunque puede ser utilizado sin problemas en cualquier ordenador.

En realidad su creador ha rescatado el código de un viejo proyecto y lo ha actualizado para los tiempos actuales. De hecho, acaba de lanzar su versión 1.1 que incluye una jugosa novedad: su motor por defecto pasa a ser webengineview, sutituyendo a Webkit.

Kinta nos advierte que en esta primera versión no puede ser todo lo estable que sería deseable así que atentos a las actualizaciones. Además recomienda que si se tienen muchos problemas se vuelva a la versión 1.0.1.

Ttrss pocket

En resumen, una excelente alternativa que es digna de ser probada si todavía eres un ávido lector de noticias por esta vía.

Más información: KDE.Store

¿Qué son los plasmoides?

Para los no iniciados en el blog, quizás la palabra plasmoide le suene un poco rara pero no es mas que el nombre que reciben los widgets para el escritorio Plasma de KDE.

En otras palabras, los plasmoides no son más que pequeñas aplicaciones que puestas sobre el escritorio o sobre una de las barras de tareas del mismo aumentan las funcionalidades del mismo o simplemente lo decoran.

Instalar Atom en Elementary

Siempre he usado geany como IDE de desarrollo ahora, me gustaría conocer uno nuevo decidí instalar Atom

Entramos como root

sudo su

y luego ejecutamos

add-apt-repository ppa:webupd8team/atom
apt-get update
apt-get install atom

En el cual, agregamos el repositorio desde lo vamos a descargar, sincronizamos las cabeceras de los repositorios y se procede a instalar.

Ya tenemos a Atom instalado, mas adelante explico como se configura extensiones y templates.

En mi caso por que tenia instalado 32 bits, pero si tienes 64bits de un entorno debian o derivado te bajas directamente el .deb

Atom 64 Bits

Lo descargas  y luego lo instalas con dpkg -i

Lunes 19 de junio de 2017

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Witbox 2 la impresora 3D profesional y Open Source de BQ

Tengo que reconocer que hacía un porrón que no hablaba de BQ. La firma española es muy conocida por fabricar excelentes teléfonos móviles, algunos de ellos llevaron en su interior al mal logrado Ubuntu Phone, pero también destaca en otros ámbitos. Hoy quería hablar de la Witbox, su impresora 3D bajo licencia Open Source.

La Witbox 2 está destinada a profesionales que necesiten trabajar con las posibilidades que este tipo de dispositivos ofrecen para el modelado de figuras. Es capaz de trabajar en un área de trabajo similar a la de una hoja de papel DIN-A4 (21×29,7 cm) y hasta 20 centímetros de altura, ofreciendo una resolución de hasta 20 micras imprimiendo a una velocidad de impresión de hasta 200 mm/s. Además cuenta con una interesante opción de autonivelado con el que podemos lograr impresiones perfectas incluso con la plataforma inclinada.

Si esto fuera poco su diseño de hardware está licenciado bajo una licencia Creative Commons 4.0 por lo que disponemos de una gran libertad a la hora de trabajar con ella, software compatible, etc.

Witbox 2 cuesta entorno a 1600 €. Puede parecer mucho pero viendo su potencial a través del siguiente vídeo queda claro que es una máquina preciosa que se amortiza desde el primer momento que la pongamos a funcionar.

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Ya está aquí Debian 9 Stretch

Debian

Ya está aquí la muy esperada la liberación de la nueva versión de Debian. Desde el pasado sábado 17 de junio lya podemos descargar la última versión de la veterana distribución GNU/Linux. Esta es sin duda una de las más esperadas debido a los importantes cambios que incorpora.

Como  principal novedad la inclusión del kernel Linux 4.9 estable, kernel que aporta un gran número de cambios, mejoras y novedades respecto al soporte de nuevo hardware, como las tarjetas gráficas, especialmente para las gráficas AMD. También se han mejorado los controladores GPU para el Raspberry Pi y, sobre todo, de cara a la reproducción de contenido DRM desde los sistemas Linux, mejoras y novedades relacionadas con la gestión del procesador y la memoria como un mejor soporte a procesadores ATOM, etc.

Pero hay más cambios, muchos de ellos podemos consultarlos en las notas de lanzamiento. En total se han actualizado 29.859 paquetes y 15.346 son nuevos del total de los 51.687  disponibles en esta distribución.  Aunque lo mejor es echar un vistazo al siguiente cuadro comparativo.

Debian 9 Strech es LTS, es decir estable y cuenta con 5 años de soporte. Podemos descargar nuestra copia desde los siguientes enlaces en descarga directa (32 bits, 64 bits) y Torrent (32 bits, 64 bits).

 

Sábado 17 de junio de 2017

Django tu primer proyecto

La idea es saber que tienes todo lo necesario para levantar una instancia en django

Tenemos que instalar pyhton para eso, depende de tu Sistema Operativo en mi caso uso Elementary

aptitude install python

Luego entramos en la carpeta y creamos con el nombre de nuestro proyecto

mkdir entorno

Al siguiente paso accedemos dentro de la carpeta entorno
Ya dentro de la carpeta ejecutamos el siguiente comando para crear el entorno
virtualenv .
Installing distribute.............................................................................................................................................................................................done.
Installing pip...............done

Luego para entrar a nuestro entorno ejecutamos lo siguiente
source bin/activate

Ya dentro de nuestro entorno nos damos cuenta por lo siguiente la terminal se coloca de la siguiente manera
(entorno)julioh@mordor:~/githubJulioh/entorno$
Ahora procedemos a instalar
pip install django
Luego de instalar, creamos los archivos base
django-admin startproject entorno

Cuando realizamos este comando nos crea una carpeta llamada entorno y adentro los siguientes archivos.

??? db.sqlite3
??? entorno
?   ??? __init__.py
?   ??? __init__.pyc
?   ??? settings.py
?   ??? settings.pyc
?   ??? urls.py
?   ??? urls.pyc
?   ??? wsgi.py
?   ??? wsgi.pyc
??? manage.py

Luego por ultimo nos falta es levantar el servicio y verlo desde nuestro navegador

python manage.py runserver
Nos sale lo siguiente
Performing system checks...

System check identified no issues (0 silenced).

You have 13 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run ‘python manage.py migrate’ to apply them.

June 17, 2017 – 11:45:47
Django version 1.11.2, using settings ‘entorno.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Nos sale la siguiente imagen  It worked!
Congratulations on your first Django-powered page

Jueves 15 de junio de 2017

Tutorial de CouchDB

Hoy vengo a hablar de CouchDB, una base de datos que no es precisamente nueva ni es precisamente famosa, pero que en mi opinión tiene unas características únicas.

En primer lugar vayamos con la teoría. Apache CouchDB es una base de datos NoSQL que almacena documentos JSON y tiene una potente API REST. Está programada en Erlang y es un proyecto Apache desde 2008. Usa JavaScript para la operativa interna. Visto este resumen uno podría pensar que estamos ante un clon de MongoDB (a pesar de que CouchDB es mucho más antigua) pero no. CouchDB parte de una filosofía distinta, ser la base de datos de la era de la web y se nota mucho como toma decisiones que la alejan de las bases de datos relacionales y de las bases de datos NoSQL más populares.

La API REST

Una parte fundamental de CouchDB es la API REST, que es la única API que dispone. CouchDB de este modo puede funcionar de dos formas:

  • En un modelo tradicional, con una servidor que haga las peticiones. Este servidor puede estar programado en cualquier cosa (Java, PHP, Node.js, C#, Python, Ruby, Elixir,…) y que no es muy distinto a como nos conectamos por ejemplo a MongoDB o a MySQL.
  • En un modelo innovador donde la base de datos está conectada directamente a Internet y no hace falta ningún servidor que gestione la comunicación. Este modelo da lugar a las CouchApps, aplicaciones CRUD pero sin servidor propiamente dicho, solo base de datos y un alojamiento estático de archivos. A través de JavaScript en el lado del cliente podemos obtener la información, conectándose directamente el navegador con la base de datos.

La posibilidad de hacer esto último es una de las mayores ventajas de CouchDB en mi opinión, ya que según el proyecto, esto puede ahorrar mucho tiempo y prevenir muchos posibles bugs en operaciones tontas. El desafío de este artículo será crear una aplicación en CouchDB que pudiera simular a una aplicación CRUD cualquiera. Esta aplicación reducirá costes respecto a una tradicional ya que eliminamos la parte del servidor, solo mantenemos la base de datos (y un proxy).

Instalando CouchDB

CouchDB está en casi todas las distros Linux. Es posible que no esté disponible la última versión, pero para lo que vamos a hacer no es necesario. Yo voy a usar CouchDB 1.4, una versión bastante antigua, pero es la que tiene Debian en sus repos. En Ubuntu tenéis CouchDB 1.6 y en la página oficial está la versión 2.0

Creando una base de datos

En CouchDB las bases de datos son cubos sin fondo. Podemos arrojar documentos JSON sin control.

Vamos a usar la API REST para crear la base de datos “supermercado”.

curl -X PUT http://127.0.0.1:5984/supermercado

Podemos comprobar que la base de datos ha sido creada con GET

curl -X GET http://127.0.0.1:5984/supermercado

En CouchDB ciertas rutas que comienzan por barra baja son especiales. Por ejemplo si queremos pedir una lista de todas las bases de datos podemos hacer GET a _all_dbs.

curl -X GET http://127.0.0.1:5984/_all_dbs

Para borrar la base de datos usaríamos DELETE

curl -X DELETE http://127.0.0.1:5984/supermercado

Pero no lo hagas todavía. Si has pensado en lo que hemos hecho te estarás alarmando. Hemos creado una base de datos, por HTTP y no se nos ha pedido ninguna autorización ni nada. Por defecto CouchDB es inseguro ya que arranca en un modo llamado Admin Party, pero rápidamente veremos que si vamos a exponer CouchDB a Internet vamos a necesitar seguridad, y CouchDB la trae. Pero antes, vamos a trabajar con documentos.

Insertando un documento

Insertar un documento es tan fácil como tirar documentos a la papelera (bueno, quizá no tan fácil).

curl -X PUT http://127.0.0.1:5984/supermercado/UUID -d '{"nombre": "Manzana", "tipo" : "fruta", "precio" : 5}'

Donde UUID es un UUID. Si no tienes un UUID a mano, CouchDB te ofrece uno a través de _uuids.

curl -X GET http://127.0.0.1:5984/_uuids?count=10

En realidad no es estrictamente necesario poner un UUID, pero es la convención habitual. Una vez hagamos el PUT obtendremos de respuesta un JSON con tres campos muy importantes. Ok para decirnos si la operación fue bien o no, _id, con el ID del documento (es el UUID de antes) y el _rev. Este último campo, nos indica con que versión del documento hemos interactuado, en nuestro caso, era la primera así que hay un 1 delante. Esto es muy importante en CouchDB y tiene que ver con como gestiona la concurrencia. CouchDB es eventualmente consistente. Quiere decir que en una situación de escritura y lectura simultáneas, la base de datos no se bloquea sino que puede mandar distintas versione de los documentos. Cuando editemos un documentos tendremos que indicar  sobre que versión hacemos la modificación, y si algún otro cliente se nos adelantó y modificó el documento antes, tendremos que basarnos en su revisión para que sea aceptada por la base de datos. Hay que tener que CouchDB no es un sistema de control de versiones, las revisiones antiguas pueden desaparecer sin previo aviso. Esta característica, la de ser eventualmente consistente, también facilita mucho su desempeño en clústeres, pero no vamos a entrar en ello. De momento hay que saber que en CouchDB, a diferencia de otras bases de datos, para actualizar un documento necesitaremos su ID y su revisión.

Para ver el documento conociendo su ID hacemos un simple GET

curl -X GET http://127.0.0.1:5984/supermercado/UUID

Nos devuelve el documento entero junto con las propiedades _id y _rev.

Actualizando un documento

El precio de las manzanas ha cambiado, vamos a actualizarlo. El proceso es muy simple, es como insertar un documento pero añadimos la revisión sobre la que queremos hacerlo. Es importante mencionar que CouchDB no preserva nada en las actualizaciones. Si quieres dejar campos sin tocar, tendrás que volver a subirlos.

curl -X PUT http://127.0.0.1:5984/supermercado/98c003b03bc8aa87cb05983d1c000713 -d '{"_rev": "1-eba25568090eb2dfffad770b55147a67","nombre": "Manzana", "tipo" : "fruta", "precio" : 4}'

Para borrar documentos necesitas usar DELETE indicando el número de revisión.

curl -X DELETE http://127.0.0.1:5984/supermercado/98c003b03bc8aa87cb05983d1c000713?rev=2-298fdb46385be60609b242b3e5cc3566

(pero no lo hagas)

Vistas

Todo muy bonito, pero, ¿cómo accedo a la información? En SQL usaríamos SELECT, en bases como MongoDB lanzaríamos un find. En CouchDB hay que usar vistas, que se programan en JavaScript y siguen un esquema MapReduce (que recordemos, funciona muy bien en paralelo). Esto se puede hacer de varias formas. Se puede usar Fauxton, una interfaz web de CouchDB, se puede usar Erica, una herramienta para facilitar la creación y mantenimiento de CouchApps o se puede hacer con la API REST, ya que las vistas se definen en documentos JSON también.

Tenemos que crear un Design Doc. Los design doc son muy útiles y permiten por ejemplo validar documentos que vayan a entrar en la base de datos (podemos definir schemas así) o definir las vistas. Un design doc simple es así. Definimos una vista llamada all con una operación map.

 

{
    "views" : {
        "all" : {
            "map" : "function(doc){ emit(null,doc); }"
        }
    }
}

Si lo tenemos guardado en un archivo JSON

curl -H "Content-Type: application/json" --data @super.json -X PUT http://127.0.0.1:5984/supermercado/_design/super

Ahora vamos a ejecutar la vista

curl -X GET http://127.0.0.1:5984/supermercado/_design/super/_view/all

Obtenemos un objeto JSON con todos los documentos que contiene la base de datos supermercado. Por supuesto es posible crear distintos documentos de diseño, con distintas vistas cada uno.

Las vistas solo las debería poder crear el administrador de la base de datos, por lo que al contrario que en otras bases de datos, el cliente no podrá realizar operaciones que no hayan sido definidas antes. En realidad, no es del todo cierto, ya que en CouchDB 2.0 se añadió Mango, un lenguaje de consulta declarativo que permite realizar cierta operativa sin usar las vistas, pero no es tan potente.

Otro ejemplo:

{
    "views" : {
        "by-price" : {
            "map" : "function(doc){ emit(doc.precio,doc); }"
        }
    }
}

Esta vista puede ser llamada con parámetros

curl -X GET http://127.0.0.1:5984/supermercado/_design/super/_view/by-price?descending=true&limit=1

CouchDB realiza la operación de ordenado por su cuenta con el valor del key que devolvemos.

La base de datos en el salvaje oeste

Ahora vamos a ver como exponer CouchDB al salvaje Internet sin comprometer seguridad. En primer lugar toca hablar de los usuarios. Como hemos dicho, CouchDB arranca en el modo Admin Party. Este modo será desactivado en cuanto creemos un usuario como admin. CouchDB soporta además usuarios tradicionales, una característica muy útil que veremos después como usar.

Para crear un usuario como admin lanzamos esta petición:

curl -X PUT http://127.0.0.1:5984/_config/admins/aarroyoc -d '"MiPassword"'

A partir de ahora ya no estamos en una admin party y si intentamos crear una base de datos veremos que CouchDB nos deniega el acceso. Sin embargo, otras tareas como subir documentos a bases de datos ya existentes todavía funcionan.

Para protegernos mejor debemos saber los tipos de autorización que soporta CouchDB. En primer lugar soporta HTTP Basic Auth, un método en el que mandamos el usuario y la contraseña en texto plano en cada petición. Esto no es para nada seguro, pero combinado con SSL no es mala opción. Sin embargo sigue sin ser la mejor solución para los expertos en seguridad. CouchDB también acepta autenticación por cookies. Las cookies duran 10 minutos por defecto y se generan haciendo una petición a _session con formato de formulario HTTP.

curl -vX POST http://127.0.0.1:5984/_session -H "Content-Type:application/x-www-form-urlencoded" -d "name=aarroyoc&password=MiPassword"

Que nos devuelve una cookie válida para operar en la base de datos

Existen plugins que permiten gestionar desde CouchDB autorizaciones más diversas, como por ejemplo OpenID o OAuth2, pero pueden complicarnos mucho el desarrollo.

Los usuarios normales se guardan en la base de datos especial _users y se les puede asignar roles, con permisos para cada base de datos. Por defecto, se pueden crear cuentas de usuario nuevas de forma tan simple como así:

curl -X PUT http://127.0.0.1:5984/_users/org.couchdb.user:USUARIO -d '{"name" : "USUARIO", "password" : "MiPassword", "type" : "user", "roles" : []}'

Es importante seguir el esquema org.couchdb.user:USUARIO para los documentos. Los roles solo los puede ajustar una cuenta de admin, así que en las peticiones anónimas deberá ir vacío.

Si en algún momento quieres saber cuántos usuarios tiene la base de datos, puedes usar la vista predefinida _all_docs.

curl -X GET http://usuarioadmin:contraseñaadmin@127.0.0.1:5984/_users/_all_docs

Estos documentos de usuarios por defecto son privados pero podemos mostrar cierta información para el resto de usuarios, sobretodo si añadimos campos extra a los documentos

curl -X PUT http://usuarioadmin:contraseñaadmin@127.0.0.1:5984/_config/couch_httpd_auth/public_fields -d '"name"'

Hará visible el campo name a todas las peticiones GET anónimas a ese documento de usuario.

Accesos a la base de datos

Ahora vamos a ver como controlar las lecturas y escrituras de una base de datos en concreto. Aquí creo que CouchDB tiene limitaciones y que debe ser algo en lo que enfocarse en futuras versiones pues es un control muy limitado. Si fuese una base de datos interna no sería mucho problema, pero teniendo en cuenta que va a estar expuesta a Internet sería necesario algo más potente. Eso no quiere decir que no se puedan hacer cosas, pero vamos a tener que tirar de funciones JavaScript internas.

Por un lado, tenemos un documento especia en cada base de datos llamado _security. Este contiene listas de admins y miembros. Las listas pueden estar vacías, contener usuarios o contener roles. En caso de que la lista de miembros este vacía se considera que todos los usuarios son miembros (incluido los anónimos). Los miembros pueden leer y escribir todos los archivos. Esto es muy insuficiente. Por poner un caso completo, yo necesitaba:

  • Que todos los usuarios pudieran leer los documentos (incluido anónimos)
  • Que todos los usuarios registrados pudieran crear documentos
  • Que solo se pudiesen modificar los documentos creados por cada usuario

Esto se puede hacer si obligamos a los documentos a que especifiquen un dueño. Todo lo podemos hacer en esta función:

function (new_doc, old_doc, userCtx){
    if(!userCtx.name)
        throw({forbidden: "Not authorized"});

    if(!new_doc.owner)
        throw({forbidden: "Plase, set an owner"});

    if(new_doc.owner != userCtx.name)
        throw({forbidden: "Owner in document should be the same as user"})

    if(old_doc!=null)
        if(old_doc.owner != userCtx.name && userCtx.roles.indexOf("_admin") < 0)
            throw({forbidden: "Not your document"});
    return;
}

Esta función puede ser subida a CouchDB con la API HTTP dentro de un design doc. El design doc quedaría así:

{
        "_rev" : "7-670f7428b5a5afb25ec61382024f0733",
        "views" : {
                "all" : {
                        "map" : "function(doc){ emit(doc.name,doc); }"
                },
                "by-price" : {
                        "map" : "function(doc){ emit(doc.precio,doc); }"
                }
        },
        "validate_doc_update":"function (new_doc, old_doc, userCtx){\n    if(!userCtx.name)\n        throw({forbidden: \"Not authorized\"});\n\n    if(!new_doc.owner)\n\tthrow({forbidden: \"Plase, set an owner\"});\n\n    if(new_doc.owner != userCtx.name)\n        throw({forbidden: \"Owner in document should be the same as user\"})\n\n    if(old_doc!=null)\n        if(old_doc.owner != userCtx.name && userCtx.roles.indexOf(\"_admin\") < 0)\n            throw({forbidden: \"Not your document\"});\n    return;\n} \n"
}

Por supuesto, en _rev irá la revisión que toque. Este sistema es más potente de lo que parece ya que podemos controlar todos los detalles de la operación. Es por ello que muchas veces la función validate_doc_update es la más compleja de los documentos de diseño. Para ayudarme un poco, estoy usando Node.js para leer archivos JavaScript y pasarlos a una cadena JSON válida.

CORS y SSL

Vamos a lanzar CouchDB a Internet. En primer lugar, un par de detalles. CouchDB idealmente vivirá en un dominio separado a la web estática. Para que las peticiones JavaScript funcionen hay que activar CORS. También vamos a proteger los datos así como los usuarios y contraseñas transmitidos. Todo esto podemos hacerlo del tirón con nginx:

 

server {
        listen 443 ssl http2;
        ssl_certificate /etc/letsencrypt/live/alejandria.adrianistan.eu/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/alejandria.adrianistan.eu/privkey.pem;
        server_name alejandria.adrianistan.eu;
        location / {
                add_header Access-Control-Allow-Origin *;
                proxy_pass http://localhost:5984;
                proxy_redirect off;
                proxy_set_header Host $host;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Ssl on;
        }

        location /_utils/ {
                return 404;
        }
}

¡Listo! Ya tenemos una instancia de CouchDB directamente conectada a Internet. Como podéis comprobar es una alternativa muy interesante en muchos casos. Sin embargo, ciertas cosas son un poco diferentes y más complejas de realizar. Mencionar que CouchDB también es posible usarse con un servidor de por medio en un esquema tradicional. En este caso, podemos usar la cuenta de admin para crear bases de datos personales para cada usuario. Este enfoque es necesario si necesitamos que los datos sean privados o queremos afinar más que roles tienen acceso a una base datos. CouchDB anima a crear tantas bases de datos como necesitemos, varias por usuario si es necesario, para satisfacer nuestros requerimientos. Esto no tiene gran impacto en el rendimiento tal y como está diseñado.

Puede hacerse de forma ligera, con una pequeña app que gestione el alta de usuarios y una vez creada la base de datos y ajustados los permisos se puede usar la API REST de CouchDB desde el lado del cliente con total normalidad, con protecciones de lectura y escritura más precisas.

Este modelo que hemos presentado es ideal para aplicaciones cuya base de datos principal sea pública y accesible y con unos pequeños ajustes puede adaptarse a muchas situaciones. Espero que os haya gustado el artículo. Nos hemos dejado cosas como la replicación entre nodos, los ficheros binarios o attachments ydos complementos a las vistas llamados show y lists, que permiten renderizar HTML o XML entre otras cosas, con los datos de salida de una vista si es necesario.

 

La entrada Tutorial de CouchDB aparece primero en Blog - Adrianistan.eu.

Eliminar párrafos vacíos en Writer

A veces uno se complica la vida sin darse cuenta. Durante años utilicé expresiones regulares (hablo de ellas en mi libro) para eliminar párrafos vacíos (entre otras cosas, que nunca dejo de sorprenderme con lo que la gente es capaz de cometer contra sus documentos) sin pensar demasiado en lo que hacía. ¡Error! ¡Existe una […]
Gorka Urrutia

Gorka Urrutia
Nideaderedes

Ya está disponible mi libro de programación orientada a objetos en PHP

Con un pequeño retraso pero ya está disponible mi libro de programación orientada a objetos en PHP.

En mi humilde opinión es un libro que merece la pena. En él comparto muchos años de experiencia desarrollando en PHP. Todo lo que he aprendido, lo que he sufrido y lo que me he divertido programando está reflejado en sus páginas.

Está todavía en fase “Beta” ¿qué quiere decir eso? Que todavía no está terminado y puede haberse colado algún errorcillo. Para compensarlo el precio es mucho más bajo de lo que será el precio definitivo. Pero “sin terminar” no quiere decir que tenga pocas páginas, son ya casi 120 páginas de pura sabiduría :-D.

El fatídico logo

Encuentra la batería perfecta para tu Android

Encontrar el flujo y entendimiento perfecto entre sistema operativo y consumo de recursos siempre es muy complicado. Hoy en día, todos queremos que nuestra batería esté al cien por cien el máximo de tiempo y que sea capaz de seguir nuestro ritmo diario.  Android, en este caso, no sólo nos gusta por ser libre, también por su forma de gestionar la energía, tanto por parte nativa desde su

Martes 13 de junio de 2017

Un corto CC basado en Pepper&Carrot

Hace ya un año hablé en este blog de la tira cómica de David Revoy, Pepper&Carrot, la cual no solo se libera con licencia CC sino que además está completamente desarrollada con software libre. Pues bien, el proyecto Morevna ha realizado, también con software libre y también con licencia CC, una versión animada del episodio […]

Todo el mundo debería tener su propia App Móvil

Cualquiera que tenga una página web o otro medio de comunicación en internet debería tener una app. Esta permite conectar directamente con cada cliente, permite mandar notificaciones personificadas y así aumentar las ventas, conversiones o visitas. Los teléfonos móviles han aumentado su cuota y ya superan al ordenador en cantidad de personas que lo usan […]

La entrada Todo el mundo debería tener su propia App Móvil aparece primero en Blog de Informática ✏ Luisi.

Sábado 10 de junio de 2017

Lenin Hernandez

Lenin Hernandez
Leninmhs

Como instalar la ultima versión de Firefox en Debian Jessie, vía APT

En esta breve entrada lograras tener la ultima versión del navegador web Firefox en tu sistema Debian. Lo instalaremos agregando el repositorio de firefox para Debian, con lo cual podremos mas adelante volver a actualizar y obtener la versión mas reciente cuando pase algo de tiempo. Pasos para instalar ultima versión de Firefox en Debian … Sigue leyendo Como instalar la ultima versión de Firefox en Debian Jessie, vía APT

Viernes 09 de junio de 2017

Stacer, mantén tu Linux optimizado

Cuando nos decidimos a hacer el paso de otro sistema operativo a Linux, la mayoría tiene la impresión de que va a usar el sistema operativo más seguro y que además va a tener que hacer pocas cosas para mantenerlo una vez configurado todo correctamente.  Usar Linux, no significa olvidarse de mantener a salvo nuestros archivos ni con vida a nuestro ordenador y mucho menos a nuestro

Miércoles 07 de junio de 2017

Una foto del 2006

Es una foto del 4 Foro Mundial de Conocimiento Libre, realizado en Maturín

Con mi camisa de Debian que no se a donde fue a parar.


 

Martes 06 de junio de 2017

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Conoce los ganadores de los premios OpenAwards 2017

El pasado día 1 de junio se celebró una nueva edición de OpenExpo. La feria que es referente en nuestro país para todos aquellos apasionados y empresas que apuestan por el código abierto como modelo de negocio o apoyo estratégico a su actividad.

Dentro de la programación del evento también tiene lugar la entrega de premios de los OpenAwards, que premian aquellos proyectos y medios por sus aportes a la comunidad. La lista completa de ganadores puede consultarse en el siguiente enlace.

Por nuestra parte aprovechamos para felicitar a Scalera que ha resultado ganador como mejor blog y  en especial agradeceros a todos aquellos que nos han votado porque sin ellos no habríamos logrado quedar finalistas. Muchas gracias

 

Viernes 02 de junio de 2017

WebAssembly para tontos (usando Rust)

Una de las cosas que más me han sorprendido del mundo web en estos años fue el proyecto WebAssembly. Un proyecto que pretendía traer un bytecode unificado para navegadores. Un proyecto que permitiría compilar prácticamente cualquier lenguaje a la web sin necesidad de tocar JavaScript.

El proyecto surgía de iniciativas fracasadas de Google (PNaCl) y de Mozilla (asm.js). Pero a este proyecto se unieron Microsoft y Apple, por lo que la compatibilidad estaba asegurada.

WebAssembly es un bytecode (como el de Java o el de .NET) que puede ser ejecutado por un navegador, cada navegador implementa su máquina virtual. También es posible usarlo en otros entornos relacionados con el mundo JavaScript como Node.js. Sin embargo entre los objetivos de WebAssembly está no estar atado a JavaScript, por lo que la especificación puede ser implementada por cualquier otro tipo de entorno. Actualmente WebAssembly no tiene recolector de basura y no tiene acceso directo a las Web API. No obstante, sigue siendo un proyecto interesante. Vamos a ver como usar WebAssembly con Rust.

Instalando Rust y Emscripten

Instala Rust, la versión estable es compatible con lo que queremos. Recomiendo usar Rustup.

curl https://sh.rustup.rs -sSf | sh

El paso clave es instalar un nuevo target, el target de WASM32 (WebAssembly de 32 bits).

rustup target add wasm32-unknown-emscripten

Por supuesto también hace falta instalar Emscripten.

Descarga la versión portable de Emscripten aquí. Descomprime y ejecuta

source ./emsdk_env.sh
emsdk update
emsdk install latest
emsdk activate latest
source ./emsdk_env.sh
emcc -v (para comprobar)

Emscripten ya estará instalado junto con Clang y las piezas claves de LLVM necesarias.

Escribiendo el programa en Rust

Vamos a escribir un programa simple. Un hola mundo.

 

fn main(){
    println!("Hola mundo - WebAssembly + Rust");
}

Compilamos con rustc

 

rustc --target=wasm32-unknown-emscripten main.rs -o main.html

Esto genera diversos archivos: main.html, main.js, main.wasm y main.asm.js (para compatibilidad con navegadores que no tienen WebAssembly). El fichero .wasm contiene el bytecode, si intentas abrirlo verás que es ilegible. Sin embargo, Chrome, Firefox, Edge, Safari y Node.js entenderán ese archivo. Probamos el fichero main.html en Firefox (cuya última versión soporta WebAssembly por defecto):


Usando este sistema compilamos aplicaciones enteras. Si se ajustan ciertos parámetros de Emscripten y se usa una crate adecuada en Rust puede usarse para generar juegos 3D usando WebGL escritos 100% en Rust.

Cargas librerías en Rust desde JavaScript

En el paso anterior vimos como compilar a WASM aplicaciones enteras. Ahora vamos a compilar el código de Rust a una librería y vamos a cargarlo con JavaScript.

La librería va a ser muy simple:

#[no_mangle]
pub fn random_number() -> i32 {
    42
}

fn main() {

}

Ahora compilamos el fichero a WebAssembly

rustc --target=wasm32-unknown-emscripten random.rs

Ahora vamos a cargar el fichero random.wasm. Para ello usaremos la ayuda de random.js, que contiene el código necesario para cargar el fichero WASM así como definir los imports que el código Rust espera (variables de entorno, funciones globales, etc).

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8"/>
	</head>
	<body>
		<script>
		var Module = {
			wasmBinaryFile: "random.wasm",
			onRuntimeInitialized: main,
		};
		function main() {
			var random_number = Module.cwrap("random_number","number",[]);
			alert(random_number());
		}
		</script>
		<script src="random.js"></script>
	</body>
</html>

Usando este sistema, podemos ir añadiendo código WASM poco a poco en nuestras webs.

 

Conclusión

 
Como vemos, ya es posible hoy día usar WebAssembly en nuestros proyectos. Para crear el código WebAssembly podemos usar Rust. El código WASM puede interactuar con el código JavaScript existente. ¿Qué opináis de WebAssembly? ¿Creéis que puede suponer un antes y un después en el mundo web o se seguirá usando JavaScript de forma masiva?

 

La entrada WebAssembly para tontos (usando Rust) aparece primero en Blog - Adrianistan.eu.

Miércoles 31 de mayo de 2017

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Los capítulos del libro de PHP orientado a objetos

Acabo de publicar el listado provisional de capítulos del libro programación orientada a objetos en php. Más o menos serán éstos:

  1. Herramientas
  2. El estándar PSR
  3. Introducción express a PHP
  4. Programación orientada a objetos
  5. Un ejemplo paso a paso
  6. Encapsulación
  7. Herencia
  8. Introducción al desarrollo guiado por pruebas
  9. Interfaces
  10. Clases abstractas
  11. Introducción a Git
  12. Términos y definiciones

Es posible que los reorganice pero seguramente éste será el orden final. Todavía faltan algunos más para terminar el libro.

Privacidad en Internet – Ventajas de un navegador anónimo

Nunca nada ha sido gratis o por lo menos “completamente” gratis. Y ahora mismo estamos pagando por tener acceso a todo el contenido de Internet. No me refiero a pagar por nuestro ADSL o fibra óptica, va mucho más allá. Pagamos con nuestros datos personales, tú eres un posible cliente para cualquier empresa y conocerte, […]

La entrada Privacidad en Internet – Ventajas de un navegador anónimo aparece primero en Blog de Informática ✏ Luisi.

Lunes 29 de mayo de 2017

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Para aprender a programar con objetos en PHP (pero de verdad)

Si llevas años programando en PHP y te asustan los objetos estás de enhorabuena 😀 Estoy preparando un libro para aprender a programar con objetos en PHP (pero para aprender de verdad).

Está ya listo al 80%, el prelanzamiento será en unos pocos días.

Interfaces, Clases Abstractas, Traits, estos conceptos y muchos más se explican en el libro. Y los entenderás de verdad, qué son y para qué se usan. También hablaré de buenas prácticas, principios SOLID, patrones de diseño y herramientas muy útiles como Composer, PHPUnit o Git.

El fatídico logo

Miércoles 24 de mayo de 2017

Triángulo de Sierpinski en JavaScript

Un amigo me propuso esta mañana que viera un vídeo de Numberphile, concretamente uno titulado Chaos Game. El vídeo es bastante interesante y habla de como de una aparente aleatoriedad es posible sacar fractales y patrones regulares. Esta misma mañana al llegar a casa y antes de comer me he picado y me he puesto a implementar el algoritmo en JavaScript usando el Canvas de HTML5. El resultado lo tenéis aquí:

http://adrianistan.eu/sierpinski/

Y el código que lleva es el siguiente:

const COLOR_LIST = ["red","green","yellow","pink","brown","purple","cyan","blue","orange"];

function punto(x,y){
    var p = {
        x:x,
        y:y
    };
    return p;
}

function puntoMedio(p,q){
    var m = {
        x: Math.round((p.x+q.x)/2),
        y: Math.round((p.y+q.y)/2)
    };
    return m;
}

function getRandomColor(){
    return COLOR_LIST[Math.floor(COLOR_LIST.length * Math.random())];
}

function dibujarPunto(ctx,p,size){
    ctx.fillStyle = getRandomColor();
    ctx.fillRect(p.x,p.y,size,size);
}

function $(id){
    return document.getElementById(id);
}

function get(id){
    return Math.round(document.getElementById(id).value);
}

function main(){
    var canvas = document.getElementById("canvas");
    var ctx = canvas.getContext("2d");

    var interval;

    $("start").addEventListener("click",function(){

        var size = get("size");
        var vertex = [punto(get("a-x"),get("a-y")),punto(get("b-x"),get("b-y")),punto(get("c-x"),get("c-y"))];

        let p = punto(get("s-x"),get("s-y"));

        dibujarPunto(ctx,p,size);

        interval = setInterval(function(){
            var q = vertex[Math.floor(3*Math.random())];
            p = puntoMedio(p,q);
            dibujarPunto(ctx,p,size);
        },get("speed"));
    });

    $("stop").addEventListener("click",function(){
        clearInterval(interval);
    });

    $("reset").addEventListener("click",function(){
        ctx.fillStyle = "white";
        ctx.fillRect(0,0,600,600);
    });
}

window.addEventListener("DOMContentLoaded",main);

Con distinto número de vértices existen otros fractales, también muy chulos. Incluso en el vídeo de Numberphile realizan un fractal con un gran parecido a una hoja de helecho, usando dos triángulos y una ligera modificación del algoritmo.

Un saludo y soñad con fractales.

La entrada Triángulo de Sierpinski en JavaScript aparece primero en Blog - Adrianistan.eu.

Lunes 22 de mayo de 2017

Como hacer una foto con la webcam de forma programada en Ubuntu

Continuando con el artículo que escribí hace unos días sobre xbacklight y backlight-indicator, hoy le toca a como hacer una foto con la webcam.

El funcionamiento de backlight-indicator es muy sencillo. Esta aplicación hace una foto con la webcam y la procesa para calcular el brillo. Una vez calculado el brillo lo configura para tu pantalla.

Ahora bien, ¿Cómo podemos hacer una foto con la webcam?…

Como hacer de forma programada una foto con la webcam en Ubuntu

Hacer una foto con la webcam

Hasta la fecha, en backlight-indicator utilizaba GStreamer, para tomar una foto con la webcam. Esto tenía un problema, y es que necesitaba guardar la imagen en el disco duro para luego procesarla.

Hace poco, me topé con python-v4l2capture, un proyecto en GitHub que se dedicaba única y exclusivamente a esto. Es decir, a capturar vídeo con video4linux2, una API de captura de vídeo en Linux.

El uso y funcionamiento es muy sencillo, y permite integrarlo fácilmente con cualquier aplicación en Python. Y aquí es donde puedes sacarle un importante partido…

Automatización de fotografías

Un uso muy interesante de esta sencilla utilidad es el de una foto con la webcam… (evidentemente), pero esto lo puedes automatizar por ejemplo para que se tome una foto cada vez que se inicie una sesión en tu equipo, de forma que puedes rastrear quien lo utiliza. Es decir, tendrías claras pruebas…

Vamos a ello…

Primero realizaremos un sencillo script en Python, que puedes descargar desde la propia página de GitHub, captura una foto

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from PIL import Image
import select
import time
import datetime
import v4l2capture

video = v4l2capture.Video_device("/dev/video0")
size_x, size_y = video.set_format(1280, 1024)
video.create_buffers(1)
video.start()
time.sleep(2)
video.queue_all_buffers()
select.select((video,), (), ())
image_data = video.read()
video.close()
image = Image.frombytes("RGB", (size_x, size_y), image_data)
image.save('/tmp/{0}.jpg'.format(
    datetime.datetime.now().strftime('%Y%m%dT%H%M%S')))

Lo primero es darle permisos de ejecución. Para ello, ejecutaremos la siguiente orden,

chmod +x take_photo.py

Luego lo pondremos en el algún sitio accesible, por ejemplo,

cp take_photo.py /usr/local/bin

Ahora vamos a realizar un sencillo lanzador que colocaremos en el lugar adecuado, de forma que cada vez que alguien inicie nuestro equipo, realice la captura con la webcam. Para ello crearemos el siguiente lanzador ~/.config/autostart/takephoto.desktop,

    [Desktop Entry]
    Type=Application
    Exec=/usr/local/bin/take_photo.py
    Hidden=true
    NoDisplay=true
    X-GNOME-Autostart-enabled=true
    X-GNOME-Autostart-Delay=2

De esta manera, cada vez que se inicie tue equipo y transcurridos 2 segundos se realizará una captura de pantalla… guardando una prueba de quien estaba utilizando el equipo. Evidentemente, puedes modificar el momento en el que se realiza la captura

La imagen la guarda en /tmp con el formato YYYMMDDThhmmss.jpg

Otras interesantes utilidades

Además de esto, puedes darle mas utilidades a esta aplicación. Por ejemplo si tienes una segunda webcam y quieres que tome una imagen cada cierto tiempo, o cualquier otra idea similar. Son utilidades muy sencillas pero que pueden ahorrarte mucho trabajo.

Instalación

Antes de poder utilizar esta aplicación, necesitaremos instalar la biblioteca que nos da acceso a su uso. Esta biblioteca no se encuentra en los repositorios oficiales de Ubuntu, pero la puedes instalar fácilmente ejecutando las siguientes órdenes en un terminal,

sudo add-apt-repository atareao/atareao
sudo apt update
sudo apt install python3-v4l2capture

La entrada Como hacer una foto con la webcam de forma programada en Ubuntu aparece primero en El atareao.

Domingo 21 de mayo de 2017

Liher Sanchez

Liher Sanchez
El blog de Liher

Batería externa solar para moviles

A todos los que nos gusta la informática y los móviles no podemos evitar el estar mirando productos en Internet y nos produce curiosidad el encontrar algunos de ellos, como es el caso. Tengo un móvil con una batería bastante buena, de 4.000 mAh, me suele durar todo el día sin problemas salvo que haga un uso muy intensivo, pero siempre esta bien tener una batería auxiliar por si acaso.

Mi pareja tiene una batería de 16.000 mAh de capacidad y yo la he usado en alguna ocasión pero me parece muy grande. La suelo usar en algunas ocasiones en combinación con una lampara LED USB cuando abro algún ordenador ya que la lampara tiene un brazo flexible y la batería la puedo poner en la posición que quiera, por lo que  viene muy bien para iluminar los rincones internos de los ordenadores.

Y en estas estoy cuando me he encontrado con una batería externa que me ha llamado mucho la atención por varias razones. Os hablo de una batería de 5.000 mAh que tiene tres características que me gustan mucho. Si queréis mas información solo tenéis que visitar la web en la que la venden aquí. Su precio es de unos 15 euros pero podéis conseguirla por unos 11 si usáis un cupón que os ofrezco, “L1665RO”, poniendo ese texto al comprarla conseguiréis ese estupendo precio. La primera es la capacidad ya que me serviría para llenar mi móvil en caso de necesidad. La segunda es que la carga se puede hacer mediante un panel solar que tiene incorporado, por lo que no influiría en la factura de la luz, hoy en día hay que mirar esto ya que la electricidad cada vez es mas cara. Y la tercera característica que me gusta mucho es que viene con una linterna incorporada.

 

 

Tengo que mirar mas aunque esta batería tiene muchas opciones que acabar entre mis complementos para el móvil ya que, ademas, me serviría para mas cosas ya que podría ser mi herramienta ideal para poder tener buena iluminación cuando abra cualquier ordenador. La capacidad  de 5.000 Mah que tiene para estar hecha a medida para la capacidad de la batería de mi teléfono móvil. Otra cosa que me llama mucho la atención es que se carga mediante la luz solar y, como ya he dicho antes, es algo a tener muy en cuenta con lo que cuesta enchufar cualquier cosa en casa.

Nunca había pensado en la opción de necesitar un aparato de este tipo pero si sueles ir de acampada no te puede faltar una batería como esta por las múltiples utilidades que le podíamos dar.

Un saludo a todos.

Liher Sanchez

Liher Sanchez
El blog de Liher

Este blog es para recien iniciados en Linux y lo seguira siendo

Todos los que escribimos en un blog lo hacemos por varias razones. En mi caso abrí este blog porque me gusta escribir sobre Linux y diseño web, aunque este último tema todavía no lo he tocado lo que me gustaría. Esas son las temáticas que trato aquí e intento que todo lo que publico sea accesible a cualquier tipo de usuario, pero especialmente a los usuarios que están empezando a usar Linux y que necesitan ayuda para entender conceptos sencillos.

Yo mismo me vi en ese grupo de usuarios hace unos años cuando empecé a usar Linux, y para algunas cosas todavía estoy en el. Por aquel entonces me costaba encontrar explicaciones sencillas a conceptos nuevos para mi, como por ejemplo saber que es un repositorio, lo cual es algo muy sencillo pero si no das con el artículo adecuado puede generar confusión.

También, al igual que otros muchos usuarios, recibí mas de una mala contestación a alguna de mis preguntas, lo cual es algo bastante desagradable, ya que solo pretendía aprender. Muchos dirán que antes de preguntar habría que mirar la ayuda que viene con el sistema operativo, pero suelen estar llena de palabras técnicas que pueden conseguir generar mas dudas todavía. Quiero aclarar, para los que no me conocen, que no empece en esto de la informática ayer y que no soy un usuario sin conocimientos. A día de hoy llevo 25 años entre ordenadores, soy programador informático y diseñador web, ademas de arreglar ordenadores a familiares y amigos desde hace años, incluso llegue a hacerlo en una tienda de reparación de ordenadores de la que me llamaban cuando tenían mucho trabajo o no sabían hacer algo.

Si yo, que no soy un neófito ahora ni cuando empece en Linux, he necesitado y necesito ayuda, ¿que se puede decir de aquellos que no son informáticos? Pues que necesitan toda la ayuda que podamos darles y para ellos abrí este blog.

¿A que viene todo esto? Pues muy fácil, he recibido un par de comentarios en los cuales me dicen que el contenido que publico es muy simple. El primero de ellos es en un artículo en el cual muestro como usar el icono del Launcher de Ubuntu para maximizar o minimizar una ventana y que supuso que Dario me dejase este comentario:

 

comentario blog 1

 

El otro articulo en el que recibí un comentario de este tipo es uno en el que mostraba como permitir el contenido remoto en los emails por defecto en Thunderbird y el comentario que me dejo Targarian es el siguiente:

 

comentario en el blog 2

 

Como ya he dicho este blog lo creé orientado a los usuarios que se están iniciando en el mundo de Linux y que buscan respuestas lo mas claras posibles a los términos que se manejan en este sistema operativo y tutoriales explicados de la forma mas sencilla que pueda para ayudarles y que no lo abandonen.

Hay otros blogs mucho mas técnicos y de usuarios que saben muchísimo mas que yo como el de Linuxito, el cual recomiendo visitar y seguir, que tienen artículos mas complejos y que serán del agrado de usuarios como Dario y Targarian. Quiero decir también que tanto estos dos usuarios como cualquier otro siempre serán bien recibidos aquí, pero me gustaría, que es el objetivo de este articulo, que entendiesen que hay usuarios que tienen dudas sobre cosas sencillas y que si una persona quiere saber como cómo listar y setear ACLs en formato NFSv4, por citar algo complejo, y otra persona quiere saber como minimizar una ventana desde el Launcher de Ubuntu, ambas tienen que poder encontrar tutos sobre ello en Internet. Entre los blog mas avanzados y los mas sencillos creo que formamos un equipo con el cual satisfacemos las necesidades de muchos usuarios y espero y deseo que siga siendo así.

Gracias al trabajo gratuito que hacen muchos programadores en todo el mundo desarrollando Linux podemos disfrutar de el en nuestros ordenadores y, gracias a blogs como este o el de Linuxito, muchos usuarios aprenden a manejarse en el y resuelven sus dudas o aprenden a hacer esto o aquello.

Otra razón por la que abrí este blog es que en algunos sitios en los que pregunté mis dudas no recibí respuesta de ningún tipo, eso en este blog no ha pasado nunca y no va a pasar, todos los comentarios que habéis hecho han sido respondidos, aunque sea para decir que no tengo los conocimientos necesarios para poder ayudar, pero al menos he respondido.

Un saludo a todos.

¿Qué es, como defenderme y eliminar un Ransomware?

Simplificando al máximo es un programa creado para hacer mal, lo que hace es encriptar nuestros archivos y para que un ciberdelincuente consiga una suma de dinero a cambio de recuperarlos. Se oculta dentro de otro programa que sí puede ser legítimo (por eso hay que tener cuidado al descargar programas o archivos desde páginas […]

La entrada ¿Qué es, como defenderme y eliminar un Ransomware? aparece primero en Blog de Informática ✏ Luisi.

Sábado 20 de mayo de 2017

Liher Sanchez

Liher Sanchez
El blog de Liher

Un móvil con dos pantallas

En varias ocasiones os he hablado de teléfonos móviles en el blog, es algo que me apasiona y me gusta estar al día. Siempre estoy mirando webs en las que se venden los nuevos modelos para ver como evoluciona el mercado y, algunas veces, suelo encontrarme con sorpresas.

En esta ocasión os quiero hablar de un teléfono móvil con dos pantallas que es encuentran en la parte frontal del terminal. Al principio me costaba imaginar las ventajas de esta segunda pantalla pero la idea esta muy bien. Puedes tener la segunda pantalla encendida ya que es pequeña y en el ella puedes ver notificaciones o accesos a las APPs que mas uses. Al ser una pantalla pequeña su consumo no es alto por lo que no tendrá apenas incidencia en la duración de la batería.

El teléfono móvil del que os estoy hablando es el LG V20. Os haré un breve resumen para que os hagáis una idea del tipo de terminal del que estamos hablando. La pantalla principal es de 5,7 pulgadas LCD (Quantum IPS) con resolución QHD (2560 x 1440 píxeles). La secundaria es de 2,1 pulgadas con resolución 160 x 1040. Tiene el procesador Snapdragon 820 de Qualcomm, 4GB de RAM y 64 GB de almacenamiento interno ademas de tener la posibilidad de usar una MicroSD, una batería de 3.200 mAh, tienes dos cámaras en la parte trasera y una en la frontal de alta calidad. Estas especificaciones no son muy detalladas, si queréis mas información sobre este teléfono móvil podéis verla en el enlace. Os recomiendo que lo miréis, merece mucho la pena. Se me olvidó poner que viene con Android 7. Si queréis ver como es el terminal os dejo una foto para que podáis tener una primera impresión.

 

 

 

Como podéis ver en la imagen lo tenemos disponible en varios colores. También en la imagen podéis ver las dos pantallas, la secundaria esta en la parte superior y va de lado a lado.

No cabe duda que en el mercado de la telefonía móvil es muy difícil diferenciarse del resto en cuanto a innovación se refiere pero si que me parece muy buena la intención de LG de hacerlo sacando un teléfono móvil con dos pantallas, puede que se convierta en un estándar a corto plazo. De hecho el LG V20 no es el primer móvil que la marca pone en el mercado con dos pantallas ya que también lo hizo con el LG V10 que cosechó bastante éxito. En este enlace podéis ver más información sobre el terminal. Ahí podéis leer una buen análisis del terminal y saber como funciona el tema de las dos pantallas.

Y eso es todo, solo quería hablaros un poco del LG V20 y sus características ya que me parecía algo para compartir por lo curioso que es, ya que yo no había visto todavía un teléfono móvil con dos pantalla en la parte frontal.

Un saludo a todos.

Lunes 15 de mayo de 2017

Varios sistemas Linux en un PC, varias distribuciones y/o versiones

Uno de los problemas que me encuentro con el desarrollo de aplicaciones para Ubuntu es que tengo que ir probándola en las diferentes versiones que aparecen. Esto me obliga a tener una o dos distribuciones instaladas en mi equipo, porque en ocasiones, virtualizarlas no es suficiente. Desde hace tiempo, utilizo una partición donde guardo documentos. Sin embargo, esto no es suficiente. Y todo ello ha dado lugar este artículo como tener varios sistemas Linux en un PC y no morir en el intento.

El otro día mientras escuchaba un podcast de Yoyo en Salmorejo Geek sobre como guardaba sus documentos personales, me decidí a darle una vuelta mas al sistema, y esto es lo que te voy a intentar explicar a continuación.

Varios sistemas Linux en un PC, varias distribuciones y/o versiones. Portada.

Varios sistemas Linux en un PC

Antes de nada y para que nadie se lleve a engaño, indicar que todos los sistemas Linux que instalo en mi equipo son Ubuntu. Esto no quita que esta misma solución se pueda aplicar a otras distribuciones.

Desarrollo de aplicaciones en Ubuntu

Como comentaba en la introducción, el desarrollo de aplicaciones para Ubuntu se encuentra con la necesidad de revisar que cada aplicación funciona correctamente en cada una de las versiones que se liberan. Es decir, aunque yo desarrollé my-weather-indicator para Ubuntu 10.10 Maverick Meerkat, ahora en la versión 17.04 Zesty Zapus, necesito probarla también.

Esto es así, porque de unas versiones a otras cambian las librerías que utilizo en la aplicación, cambia el propio entorno de escritorio y cambia GNOME, lo que en muchas ocasiones obliga a un rediseño de la aplicación.

En otros casos…

No solo el desarrollo de aplicaciones lleva a tener varios sistemas Linux en un PC. Es posible que seas un distrohopper, es decir, uno de los tantos de usuarios Linux que disfrutan probando cada una de las distribuciones y versiones que aparecen en el extenso universo Linux.

Otra razón que se me ocurre, aunque seguro que hay cientos de razones mas, es que simplemente para según que trabajo estés mejor en un entorno de escritorio y otro.

Centralización

El problema de tener varios sistemas Linux en un PC (o no), es que en cada uno de ellos tienes documentos, y es probable que estando trabajando en un sistema quieras utilizar un documento que esté en otro sistema.

Existen diferentes soluciones para resolver esto, desde utilizar la misma partición /home para todos, a utilizar una partición independiente donde situar todos tus documentos.

El problema de la partición /home común son los archivos de configuración que puede ser que te generen problemas en un sistema operativo o en otro, por estar utilizando diferentes versiones.

Sin embargo, hay una solución muy simple, con la que no notarás el cambio de un Linux a otro… los enlaces simbólicos.

Y ¿porque no enlazarlo todo?. Pues la razón para esto radica en que al cambiar de versión, la configuración de un escritorio puede entorpecer en otra instalación…

La propuesta para resolver como tener varios sistemas Linux en un PC

Directorios

Mi propuesta es bastante simple. Cada uno de los Linux que tienes instalados en tu equipo, tiene sus directorios ~\Escritorio, ~\Documentos, ~\Descargas, etc… Elimina todos esos directorios y haz un enlace simbólico al que se encuentra en tu partición común.

Es decir, si tu partición común la montas en /datos en esta partición común tendrás un directorio que se llamará /datos/Escritorio de forma, que cada uno de los ~\Escritorio de todos los Linux instalados en tu equipo apuntaran a /datos/Escritorio.

De esta manera cuando entres en cualquiera de los sistemas Linux instalados y te enfrentes al escritorio, encontrarás exactamente lo mismo.

Esto mismo lo podemos hacer con el resto de directorios…

Configuraciones

Sin embargo, podemos ir mas lejos todavía… En mi caso particular, utilizo GIMP e Inkscape para hacer las imágenes que ves en este sitio y para mi trabajo.

Estas aplicaciones no suelen cambiar de versión tan frecuentemente como Ubuntu, con lo que su archivo de configuración, puede permanecer inalterado durante años, sin que esto afecte a las distintas versiones.

Igual que hemos hecho con los directorios, también podemos hacer con los archivos de configuración. Es decir, podemos hacer un enlace simbólico desde el directorio de configuración o archivo de configuración que se ubica en ~/.config/GIMP/ a /datos/.config/GIMP.

Siguiendo este procedimiento nos encontraremos que aunque entremos en diferentes Linux en nuestro equipo, y trabajemos con diferentes GIMP, la apariencia de cada uno de ellos siempre será la misma. Siempre y cuando tengamos instalados los mismos complementos, etc.

Esto nos llevará a ahorrar mucho tiempo y ser más productivos.

Una solución para tener varios sistemas Linux en un PC

Esta solución funciona muy bien, sin embargo, tiene un pequeño inconveniente. Cada vez que instales una nueva distribución o una nueva versión, tienes que realizar todos estos enlaces…

Para darle una solución a este problema he creado un sencillo script que realiza estos enlaces simbólicos, de forma que cada vez que instalo una nueva distribución o versión solo tengo que ejecutar el script, que por supuesto está instalado en /datos.

Este script está en GitHub. Puedes utilizarlo fácilmente, descargarlo, compartirlo, contribuir o lo que consideres.

Una indicación, en las primeras líneas de linker.py tienes el directorio de origen que no habría que modificarlo, y el directorio de destino (este a lo mejor si que consideras en borrarlo).

A continuación tienes todos los directorios a enlazar. Por supuesto que lo que enlazas es a~/ seguido del directorio o archivo que consideres. El funcionamiento es muy sencillo. Lo que hace es mirar si en /datos existe el directorio de origen, si existe borra, el directorio de tu directorio de inicio y realiza el enlace simbólico. Si en /datos no existe, primero copia el de tu directorio de inicio y luego lo enlaza.

Conclusiones

La solución de tener todo en un directorio aparte es muy buena solución tal y como lo comentaba Yoyo. Ahora, completado esto con los enlaces simbólicos, el funcionamiento es impecable. De esta manera, yo paso de una distribución, versión o instalación a otra, sin echar nada de menos. Muy recomendable.

La entrada Varios sistemas Linux en un PC, varias distribuciones y/o versiones aparece primero en El atareao.

Lenin Hernandez

Lenin Hernandez
Leninmhs

Como instalar el Antivirus para Linux “Comodo” en Debian 8 (Jessie)

¿Por qué el Antivirus Comodo? El Antivirus Comodo para Linux (CAVL) ofrece la misma protección antivirus que el mismo software para Windows con el beneficio añadido de un sistema anti-spam totalmente configurable. Con los escáneres de virus a la vista y bajo acceso, CAVL también utiliza el análisis de comportamiento basado en la nube de … Sigue leyendo Como instalar el Antivirus para Linux “Comodo” en Debian 8 (Jessie)

Lunes 08 de mayo de 2017

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Haciendo SSH a través de SSH. Rápido y fácil con ProxyCommand.

SSH a través de SSH
Como vemos en las películas de hackers. ¡Alguien ha conectado con el servidor y no podemos averiguar su IP porque ha estado rebotando a través de varios servidores! Bueno, yo me quejaría un poco de la velocidad de la conexión entre mi ordenador y el ordenador destino cuando paso por dos servidores intermedios. Pero puede ser un buen ejercicio. A la vez que útil cuando queremos ocultar el acceso a nuestro servidor o tenemos que acceder a un ordenador que está en una red privada.

En el primer ejemplo me refiero a un servidor cuyo acceso SSH está cerrado a todas las IPs exceptuando las de una red o una máquina concreta. Por ejemplo, podemos abrir el puerto SSH de nuestro ordenador de casa o nuestro mediacenter sólo a la IP de un servidor de nuestra propiedad. Así, cuando nos hagan un scan de puertos, el puerto estará cerrado. Pero cuando quiera conectarme desde fuera, primero tendré que conectarme a mi servidor y desde ahí conectarme al mediacenter de casa.

En el segundo ejemplo, imaginad que tenemos un servidor web conectado directamente a Internet, y un servidor de base de datos conectado al servidor web. Si deseamos acceder al servidor de base de datos desde Internet tendremos que entrar primero al servidor web y desde ahí acceder al servidor de base de datos. Bueno, este esquema de red lo podemos complicar mucho más. Además, esquemas parecidos nos los podemos encontrar, por ejemplo, en Amazon, cuando hemos creado una VPC con subred pública y privada y queremos acceder a las máquinas de la subred privada.

Pinceladas de seguridad

Antes de nada, os recomiendo este post sobre Consejos para endurecer un servidor SSH y hacerlo más seguro. Con muchas cosas a tener en cuenta a la hora de montar nuestro servidor SSH y aislarlo de posibles ataques desde fuera.
Otro detalle más, y muy interesante es que lo que pongo en este post debemos hacerlo siempre en servidores de confianza. Es decir, puede que tengamos acceso a un servidor SSH que hemos encontrado por Internet, que sea muy rápido y todo muy bonito. Pero al final, la clave privada de acceso al segundo servidor va a pasar por el primero para poder conectar. Como algún administrador de sistemas esté atento se puede quedar con tu clave privada y las claves privadas no se pueden dar a nadie.

Por otra parte, al conectar con un servidor intermedio y estar enviando una clave privada, si alguien intercepta el tráfico con el primer servidor y consigue descifrarlo podrá entrar en los dos servidores en nuestro nombre. Aunque son cosas difíciles de descifrar… todo es posible. Siempre es importante tener actualizado tanto el cliente como el servidor SSH en todos los puntos para que la negociación de protocolos elija siempre los algoritmos más seguros disponibles.

El método clásico. SSH, entro, SSH, entro

Lo primero que se nos puede pasar por la cabeza es hacer SSH en al primer servidor y una vez dentro hacer SSH al segundo. Esto es sencillo cuando tenemos contraseñas. Es decir, para entrar en el primero nos pide introducir contraseña y luego para entrar en el segundo también. Luego para cerrar la sesión, hacemos exit en el segundo y seguidamente exit en el primero.
Pero siempre se recomienda utilizar pares de claves pública y privada (ver los consejos para endurecer un servidor SSH). Aunque ahora empieza a ser un poco incómodo porque conectar al primer servidor es inmediato. Ya que el servidor conoce nuestra clave pública podemos entrar directamente. Pero para entrar en el segundo servidor, es decir, nuestro destino, este segundo servidor tiene que tener la clave pública del primer servidor y el primero la clave privada correspondiente. Por lo que configurar un sistema así es arriesgado:

  • Por un lado, la clave privada de acceso al segundo servidor debe estar siempre en el primero. Cualquiera podría verla, sobre todo si el usuario dentro del servidor es compartido. Aunque no es una técnica recomendable, se utiliza.
  • Configurarlo todo es un rollo, y es muy fácil confundirse con las claves. Además, para copiar en el servidor no vamos a utilizar nuestra clave privada, utilizamos otra por si las moscas.
  • Acceder al servidor es lento, necesitamos ejecutar un comando intermedio. Y luego si no queremos sólo acceder sino que queremos copiar archivos, es mucho más lío copiar los archivos al primero y una vez copiados, copiarlos al segundo.

Otro método que podríamos utilizar. VPN

Otro método interesante sería crear una red VPN entre nuestro ordenador y el ordenador de destino. Pasaríamos por el servidor VPN y tendríamos la conexión cifrada. Sobre esa conexión estableceríamos la conexión por SSH y listo. Aunque tendríamos que tener de antes la VPN. De todas formas, el método que explicaré a continuación con ProxyCommand podríamos utilizarlo para entra en la máquina antes de tener la VPN montada.

Conectar con ProxyCommand

Este método ha sido inventado precisamente para conectar con un servidor intermedio. En este caso, hacemos que para conectar tengamos que ejecutar algo en el servidor intermedio. ¿Qué ejecutamos? ssh para conectar y nc (netcat) para que el primer servidor haga de puente. Veamos la línea de conexión más a fondo:

ssh -o ‘ProxyCommand=ssh usuario@intermedio.com nc %h %p’ usuario@final.com

Con esto, hacemos que se utilize la opción ProxyCommand que justo antes de conectar hará ssh al intermedio.com (nuestro servidor intermedio) con el usuario usuario y seguidamente ejecutará nc al host y puerto con el que vamos a conectar. En nuestro caso el host sería final.com y el puerto 22 para SSH (aunque como veremos en futuros ejemplos, podremos variar estos puertos).

Perfectamente podríamos cambiar los puertos, por ejemplo SSH al puerto 221 para el servidor intermedio y el puerto 222 para el servidor final:

ssh -p222 -o ‘ProxyCommand=ssh -p221 usuario@intermedio.com nc %h %p’ usuario@final.com

Conectando de esta forma, la clave privada no tiene por qué estar almacenada en el servidor intermedio todo el tiempo, ni tampoco tendríamos que añadir una clave pública extra al servidor final. Directamente las cogerá de nuestro directorio ~/.ssh/ local. Y ssh se encargará de hacer la negociación de claves y protocolos.

Esto también podríamos añadirlo en nuestro archivo ~/.ssh/config con la siguiente información:

Host final.com
ProxyCommand ssh -p221 usuario@intermedio.com nc %h %p
Port 222

Ahora, haciendo sólo:

ssh usuario@final.com

Conectaría automáticamente con el proxy. Es decir, sería transparente para nosotros y no tendríamos que especificar el ProxyCommand todo el rato para conectar. Aún así hemos de ser conscientes que se ejecuta un netcat en el servidor, es decir, en ese punto, la información está sin cifrar. Si alguien mete mano en el nc estamos perdidos. Por lo tanto, hacedlo siempre en servidores de confianza. Además, si se compromete el servidor intermedio, tal vez no se haya comprometido sólo la clave privada para el servidor final. Así que cuidado.

Transfiriendo archivos

Podemos hacerlo con scp. Si en nuestro ~/.ssh/config hemos hecho las modificaciones anteriormente mencionadas no habrá problema, podremos hacer scp sin mover un dedo. Pero, ¿cómo sería el comando para hacer scp?

scp -P222 -o ‘ProxyCommand=ssh -p221 usuario@intermedio.com nc %h %p’ fichero_origen usuario@final.com:directorio_o_fichero_destino

Aunque lo interesante es hacerlo con rsync que nos da muchas facilidades y ventajas frente a la transmisión con scp:

rsync -avhP -e “ssh -p222 -o ‘ProxyCommand=ssh -p 221 usuario@intermedio.com nc %h %p'” edid_monitor fichero__o_directorio_origen usuario@final:directorio_o_fichero_destino

Aunque los argumentos -avhP no son estrictamente necesarios. Con rsync tengo siempre esta coletilla que me vale para la mayoría de los casos. Pero añadiremos -e con el comando para ejecutar ssh y tendremos que añadir toda la línea de conexión. Aunque, como antes, si lo tenemos configurado en ~/.ssh/config no hace falta.

Notas finales

Para realizar este tipo de conexión, debemos tener acceso al servidor intermedio y el servidor intermedio deberá tener acceso al segundo. Pero no es necesario que tengamos acceso al servidor final, es más, puede que no tengamos ping, puede que el servidor final, como dije al principio esté dentro de una red privada y el intermedio sea sólo el punto de entrada. Aunque lo pongamos en nuestro archivo de configuración (~/.ssh/config) podemos poner una IP privada a la que no tenemos acceso (siempre es mejor que los hosts tengan su nombre, pero no nos vamos a morir si no es así).
Pero insisto, el servidor intermedio sí que debe tener acceso.

Foto principal: Metropolitan transportation

The post Haciendo SSH a través de SSH. Rápido y fácil con ProxyCommand. appeared first on Poesía Binaria.

Sábado 06 de mayo de 2017

Raúl González Duque

Raúl González Duque
Linux – Mundo Geek

Linux en Windows: el Subsistema de Windows para Linux

El Subsistema de Windows para Linux o WSL es una nueva característica de Windows 10 que permite ejecutar binarios ELF64 de Linux directamente en Windows. Aunque el funcionamiento es parecido, no es exactamente una máquina virtual; es una nueva alternativa que abre montones de posibilidades, debido a una mucho mayor integración: realmente es casi como si estuviéramos ejecutando Linux en Windows, con un único sistema operativo común para las aplicaciones Windows y Linux.

Este proyecto, como decimos, permite utilizar herramientas nativas de Linux en Windows, desde una simple consola bash, a programas como vim, awk o git, ¡e incluso un entorno gráfico alternativo completo! ¿Quieres probarlo? ¡Pues sigue estas instrucciones!

Prerequisitos

Necesitas tener instalada la versión de 64 bits de Windows y tener actualizado el sistema a la compilación 14393 de Windows 10 Anniversary Update o superior.

Activar el Modo de programador

Pulsa Windows + I, y selecciona Actualización y seguridad -> Para programadores. Marca la opción de “Modo de programador”

Activar el Modo de programador de Windows 10

Instalar el Subsistema de Windows para Linux

Pulsa Windows + R, y escribe “optionalfeatures” para abrir el diálogo de “Activar o desactivar las características de Windows”. Selecciona “Subsistema de Windows para Linux (beta)”. Una vez instalado Windows te pedirá que reinicies el ordenador.

Activar el Modo de programador de Windows 10

¡Instalar Ubuntu en Windows!

Pulsa Windows + R, y ejecuta el comando “bash“. Te pedirá que aceptes la licencia de Canonical, la empresa detrás de Ubuntu, y descargará e instalará la distribución de Ubuntu Linux. Durante el proceso de instalación te preguntará si quieres establecer la configuración regional a la misma que tenga Windows (probablemente) y te pedirá un nombre de usuario y contraseña para crear una nueva cuenta.

Rock and roll

A partir de ahora ya tienes un sistema Linux totalmente funcional (aunque sin interfaz gráfica), con los comandos y el funcionamiento habitual de una distro Linux. Para iniciar la consola de Linux en cualquier momento, de nuevo pulsa Windows + R y ejecuta el comando bash.

Si queremos actualizar los paquetes del sistema que hemos instalado, al estar basado en Ubuntu, escribiríamos los siguientes comandos:

sudo apt update
sudo apt upgrade

Nuestro nuevo sistema tiene los discos de Windows montados en /mnt/, por lo que para listar los archivos en C:, por ejemplo, escribiríamos el siguiente comando:

ls /mnt/c

Para buscar un programa en los repositorios:

apt search término1 término2 término3

Para instalar un programa desde repositorio:

sudo apt install programa

Desinstalar Linux

Si en algún momento quieres desinstalar WSL, con un poco de suerte, porque prefieras instalar un Linux completo, basta con escribir el siguiente comando en la línea de comandos de Windows:

lxrun /uninstall /full /y

Lunes 01 de mayo de 2017

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Cómo obtener información de configuración del sistema Linux o tu servidor en C y C++ (II. Sistema y CPU)

Hace unos días comentábamos algunos ejemplos sobre obtención de información relativa a la memoria de nuestro sistema en C, tanto RAM, Swap, buffers, caché, como información relativa a una aplicación. También vimos cómo obtener el uptime de nuestro equipo o la carga media del sistema en 1, 5 y 15 minutos. Son cosas que podemos hacer fácilmente desde la línea de comandos y que pueden sernos muy útiles en nuestros programas. Por ejemplo para evaluar cuándo es el mejor momento para realizar una acción, realizar una limpieza, ajustar tamaños de nuestras reservas o detectar un posible error.

En el post de hoy veremos algunas utilidades para ver la configuración del sistema y con configuración me refiero a cosas propias del equipo en el que estamos ejecutando nuestro programa como el número de procesos que puede ejecutar un usuario, el número máximo de ficheros que pueden abrirse, número de cores o núcleos con los que cuenta el ordenador, cuáles de ellos están activos, características propias del sistema y muchas más cosas.

Configuración numérica del sistema: sysconf()

sysconf() es de esas funciones de unistd.h con las que podemos obtener gran cantidad de información. Es más, en este post no está todo lo que podéis obtener, sólo algunas cosas que me han parecido interesantes. Eso sí, si veis algo curioso que se me ha pasado, dejadme un comentario. Todas las posibilidades las podéis encontrar en el archivo /usr/include/unistd.h , tal vez las constantes no estén directamente ahí, pues depende de la plataforma y versión del sistema, pero es un punto de partida.
De forma general, sysconf() devuelve un long int y como entrada admite un int, aunque ese int, es mejor indicarlo con el valor de una constante, pues será mucho más significativo para nosotros y portable en caso de que cambiemos de arquitectura o versión de las bibliotecas.

Sin más dilación aquí va un listado de las constantes que podemos utilizar y la respuesta que esperamos:

  • _SC_ARG_MAX: Longitud máxima de los argumentos a la hora de ejecutar un comando.
  • _SC_CHILD_MAX: Número de procesos que puede lanzar un usuario determinado.
  • _SC_CLK_TCK: Ticks de reloj por segunto. Los sistemas operativos utilizan los ticks de reloj para medir el tiempo de los procesos que están corriendo, o para programar la realización de tareas (tiempo de vida de páginas de memoria o tiempos de espera de un recurso) o para tomar el control de forma síncrona. Un valor de 100 aquí, indica que cada 10ms se produce un tick de reloj.
  • _SC_LOGIN_NAME_MAX: Es el tamaño máximo del nombre de usuario para identificarnos en el sistema.
  • _SC_HOST_NAME_MAX: Tamaño máximo del hostname
  • _SC_OPEN_MAX: Número máximo de archivos abiertos por un proceso.
  • _SC_PAGESIZE: Tamaño de página de memoria (igual que utilizar getpagesize())
  • _SC_PHYS_PAGES: Número de páginas físicas en memoria. (Igual que utilizar get_phys_pages())
  • _SC_AVPHYS_PAGES: Número de páginas físicas disponibles en memoria. (Igual que usar get_avphys_pages())
  • _SC_NPROCESSORS_CONF: Número de núcleos del procesador.
  • _SC_NPROCESSORS_ONLN: Número de núcleos activos del procesador.
  • _SC_ATEXIT_MAX: Máximo de funciones que podemos encolar con atexit(). Cuidado con este valor, puede ser muy grande, y podemos decir que no estamos limitados.
  • _SC_SIGQUEUE_MAX: Máximo de señales que podremos encolar para un proceso.
  • _SC_LEVEL1_ICACHE_SIZE: Tamaño en bytes de la caché de procesador de instrucciones de nivel 1.
  • _SC_LEVEL1_DCACHE_SIZE: Tamaño en bytes de la caché de procesador de datos de nivel 1.
  • _SC_LEVELX_CACHE_SIZE: Tamaño en bytes de la caché de procesador de nivel X

Aquí vemos un ejemplo con algunas más:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <unistd.h>
#include <stdio.h>

int main(int argc, char* argv[])
{
    printf ("Máximo de argumentos: %ld\n", sysconf(_SC_ARG_MAX));
    printf ("Máximo de procesos por usuario: %ld\n", sysconf(_SC_CHILD_MAX));
    printf ("Ticks por segundo: %ld\n", sysconf(_SC_CLK_TCK));
    printf ("Máximo de streams abiertos: %ld\n", sysconf(_SC_STREAM_MAX));
    printf ("Máximo de archivos abiertos: %ld\n", sysconf(_SC_OPEN_MAX));
    printf ("Control de tareas POSIX: %ld\n", sysconf(_SC_JOB_CONTROL));
    printf ("Tamaño máximo del login: %ld\n", sysconf(_SC_LOGIN_NAME_MAX));
    printf ("Tamaño máximo del hostname: %ld\n", sysconf(_SC_HOST_NAME_MAX));
    printf ("Caché de instrucciones de nivel 1: %ld\n", sysconf(_SC_LEVEL1_ICACHE_SIZE));
    printf ("Caché de datos de nivel 1: %ld\n", sysconf(_SC_LEVEL1_DCACHE_SIZE));
    printf ("Caché de nivel 2: %ld\n", sysconf(_SC_LEVEL2_CACHE_SIZE));
    printf ("Caché de nivel 3: %ld\n", sysconf(_SC_LEVEL3_CACHE_SIZE));
    printf ("Caché de nivel 4: %ld\n", sysconf(_SC_LEVEL4_CACHE_SIZE));
    printf ("Núcleos del procesador: %ld\n", sysconf(_SC_NPROCESSORS_CONF));
    printf ("Núcleos online del procesador: %ld\n", sysconf(_SC_NPROCESSORS_ONLN));
    printf ("Bits que tiene un char: %ld\n", sysconf(_SC_CHAR_BIT));
    printf ("Bits que tiene un long: %ld\n", sysconf(_SC_LONG_BIT));
    printf ("Máximo de bytes en nombre de huso horario: %ld\n", sysconf(_SC_TZNAME_MAX));
    printf ("Funciones que podemos encolar con atexit(): %ld\n", sysconf(_SC_ATEXIT_MAX));
    printf ("Máximo de señales para encolar: %ld\n", sysconf(_SC_SIGQUEUE_MAX));
    printf ("Máximo número de referencias en enlaces simbólicos: %ld\n", sysconf(_SC_SYMLOOP_MAX));

    return 0;
       
}

Configuración textual de sistema: confstr()

A veces necesitamos un texto para expresar todo lo que necesitamos decir. En este caso, POSIX, nos brinda la función confstr() en la que, pasandole una cadena de caracteres, copia en ella el valor que le pedimos a través de una constante (como hacíamos antes). Aunque, claro, para reservar memoria en consecuencia (ajustado al tamaño del texto a almacenar) podemos llamar a esta función con NULL en lugar de un puntero a cadena y que nos devuelva el tamaño que necesita para almacenar el valor.

De todas formas, veremos pocos valores aquí. (Muchos de ellos son para ver flags de compilación, como vemos aquí). Por ejemplo encontramos cosas como:

  • _CS_PATH: Es la ruta donde están las utildades POSIX por defecto. Sería el $PATH más básico del sistema.
  • _CS_GNU_LIBC_VERSION: Versión de LIBC.
  • _CS_GNU_LIBPTHREAD_VERSION: Versión de pthreads.

Información del sistema operativo

Como cuando ejecutamos el comando uname, en C, tendremos una función también llamada uname que devolverá un struct utsname con la siguiente información (todos los elementos son cadenas de caracteres):

  • sysname: Tipo de sistema, como este post es sobre Linux, siempre veremos Linux
  • nodename: Nombre del equipo (hostname)
  • release: Versión del kernel
  • version: Versión del SO: Ubuntu, Fedora, Arch Linux junto con versión y fecha
  • machine: arquitectura de máquina: i686, arm, x86_64…
  • __domainname: Nombre de dominio (extansión GNU)

La longitus de cada campo no está claramente definida, en unos sistemas serán los campos más grandes que en otros. Eso sí, todos tienen terminador, el sistema operativo se asegura de ello, por lo que podemos utilizarlos de forma segura.

Aquí tenemos un ejemplo de uso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/utsname.h>

int main(int argc, char* argv[])
{
    struct utsname unameInfo;
   
    if (uname(&unameInfo)==-1)
        {
            fprintf (stdout, "ERROR\n");
            exit(-1);          
        }
       
    printf ("S: %s\n", unameInfo.sysname);
    printf ("S: %s\n", unameInfo.nodename);
    printf ("S: %s\n", unameInfo.release);
    printf ("S: %s\n", unameInfo.version);
    printf ("S: %s\n", unameInfo.machine);

    return 0;
       
}

Hostname y nombre de dominio

Aunque uname() obtenemos el nodename que a fin de cuentas es nuestro hostname. El nombre de dominio, o domain name, no está claro y no estará siempre presente, es una extensión de GNU, que puede que no siempre tengamos disponible. Así que dejaremos por aquí otro fragmento de código que puede ser muy interesante para obtener esta información:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[])
{
    char domainname[10];

    /* Podemos hacer esto, si queremos hacerlo seriamente, utilizando
         la configuración del sistema para el tamaño máximo del hostname
         asegurándonos de no tener problemas.
         Aunque siempre podríamos declarar:

         char hostname[64];

         O un valor más grande, y no vamos a tener problemas.
    */

    char* hostname;
    int hostname_size = sysconf(_SC_HOST_NAME_MAX);
    hostname = (char*)malloc(hostname_size);
   
    if (gethostname(hostname, hostname_size)!=-1)
        printf ("Hostname: %s\n", hostname);
    else
        printf ("errno: %s (%d)\n", strerror(errno), errno);

    if (getdomainname(domainname, 10) != -1)
        printf ("Domain name: %s\n", domainname);

    return 0;      
}

Información sobre la CPU

Si has curioseado alguna vez tu sistema, habrás visto un archivo llamado /proc/cpuinfo que contiene mucha información útil sobre la CPU. Como la marca, modelo, extensiones del procesador, cores físicos, fpu, familia, frecuencia para la que fue diseñado y mucho más. Podemos parsear la información de /proc/cpuinfo en C (aunque en el ejemplo utilizo una función de C++ para extraer el archivo, podríamos hacerlo en C puro si queremos). Eso sí, me gusta extraer el fichero y luego parsear la información, aunque no sea lo más rápido (podemos leer el fichero y al mismo tiempo ir extrayendo información), porque hace nuestro código más reutilizable para otras situaciones. Aquí va el ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <iostream>
#include <string>
#include <unistd.h>                         /* Utilidades UNIX */
#include <fcntl.h>                          /* Control de archivos */
#include <cstring>
#include <cstdio>
#include <cstdlib>

/** Extract a whole file into a string  */
std::string extractFile(const char *filename, size_t bufferSize=512)
{
    int fd = open(filename, O_RDONLY);
    std::string output;

    if (fd==-1)
        return "";      /* error opening */

    char *buffer = (char*)malloc(bufferSize);
    if (buffer==NULL)
        return "";      /* Can't allocate memory */

    int datalength;
    while ((datalength = read(fd, buffer, bufferSize)) > 0)
        output.append(buffer, datalength);

    close(fd);
    return output;
}

using namespace std;

int main(int argc, char* argv[])
{
    string cpuinfo = extractFile("/proc/cpuinfo");
    char* tokenized;
    char* ptrptr;

    /* Es más fácil hacer el parse con sscanf() que con streams de C++
       no es tan seguro hablando de memoria, pero este tipo de ficheros
         no suelen tener fallos y no suelen exceder unos tamaños determinados. */

    tokenized=strtok_r((char*)cpuinfo.c_str(), "\n", &ptrptr);
    while (tokenized)
        {
            char name[64];
            char value[1024];
            memset(value, '\0', 1024);
            sscanf (tokenized, "%[^\t:] : %[^\t\n]", name, value);
            cout << "["<<name<<"]" << " = " << value << "\n";

            tokenized = strtok_r(NULL, "\n", &ptrptr);
        };
 
    return 0;
}

Para parsear, en este caso prefiero las utilidades que nos da C como strtok y sscanf porque son mucho más rápidas que hacerlo con streams de C++. Además, con estos últimos tenemos que hacer algunas comprobaciones o reescribir los streams para que sea más amigable y resultarían muchas más líneas de código.

Identificador único

Si necesitas un identificador único para el equipo en el que se está ejecutando el programa, puedes leer el archivo /etc/machine-id (o generalmente podemos encontrarlo en /var/lib/dbus/machine-id y debe ser el mismo archivo) ; también podemos utilizar la función gethostid() que devolverá el mismo número que devuelve el comando hostid, aunque es un identificador muy pequeño para ser universalmente único y puede que se repita alguna vez si manejamos muchos IDs de sistema.

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main (void)
{
    printf ("%ld\n", gethostid());
    return 0;
}

Es más, este ID de host se puede definir mediante la función sethostid() sólo si eres root, pero se puede definir. Otro valor que es único para cada ordenador es el obtenido directamente del hardware. Podemos consultarlo desde /sys/devices/virtual/dmi/id/product_uuid aunque sólo podremos leerlo si somos root.

Otra forma de hacerlo es obtener información variada sobre el sistema: CPU, núcleos, MAC de interfaces de red, y en definitiva, muchos de los datos que podemos ver en este post, mezclarlos y hacer un hash.

Variables de entorno

En stdlib.h encontramos la función getenv() que nos ayuda a obtener la información encerrada en variables de entorno del sistema. No sólo para Linux. Esto lo podemos ver en práctica en este ejemplo: buscando archivos dentro de nuestro PATH.

Dispositivos de red

Para no repetirme, os remito a este post: Hallar la IP de un dispositivo de red. En el cual, no sólo podremos averiguar la IP de un dispositivo de red, sino mucha más información útil del mismo como también podemos ver aquí.

En el próximo post…

El próximo post estará dedicado a los procesos. Obtención de información propia del proceso en el que nos encontramos y otros procesos a los que tenemos acceso. Estará publicado el 15 de Mayo.

Foto principal: Team UI8

The post Cómo obtener información de configuración del sistema Linux o tu servidor en C y C++ (II. Sistema y CPU) appeared first on Poesía Binaria.

Sábado 29 de abril de 2017

Lenin Hernandez

Lenin Hernandez
Leninmhs

Como integrar GIT con el gestor de archivos Nautilus y Nemo – RabbitVCS

Cuando se es usuario cotidiano de software para control de versiones, siempre desearemos tener a disposición herramientas que nos faciliten y hagan mas evidente el trabajo. Es común conocer los comandos de tu control de versiones (GIT, SVN, Hg, etc…), contar con un cliente de control de versiones incorporado en tu editor de código favorito, … Sigue leyendo Como integrar GIT con el gestor de archivos Nautilus y Nemo – RabbitVCS

Jueves 27 de abril de 2017

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

¿Qué es un VPS y cómo crear uno en DigitalOcean? [Vídeo]


Cuando vamos a contratar un hospedaje para nuestro servicio web o nuestro blog siempre pueden surgir algunas dudas. En este vídeo intento aclarar la diferencia entre contratar un servidor compartido y un servidor privado virtual. Aunque tenemos muchas opciones entre nosotros.

Todo se explica de una forma muy general, intentando simplificar las cosas lo máximo posible. Y quiero aclarar que tener un hosting compartido en muchas ocasiones no es malo, al igual que no siempre un VPS es lo mejor.

¿Qué es un VPS? ¿Cómo crear uno en DigitalOcean?

Contratar un VPS en DigitalOcean

Este proveedor ofrece hospedaje en servidories privados virtuales asequible y de calidad. Llevo varios años con ellos, y el servicio está cada vez mejor. Hay más soporte de software y cada vez podemos hacer más cosas. Últimamente soportan balanceo de carga y almacenamiento adicional. Cosas que, si las querías antes tenías que adaptarlas a mano.
Por otro lado, puedes ayudar a mantener vivo este blog. Si contratas un servidor con DigitalOcean, cuando pagues tus primeros $25 (aunque estés en España te cobran en dólares. En abril de 2017 el dólar vale un poco menos que el euro, por lo que saldría por algo menos de 24€). Una vez agotados los $10 de bienvenida, a mí me darán otros $25 para gastar en hospedaje, con lo que habrías colaborado con los gastos del servidor y encima te habrás llevado un buen hospedaje para tu web, servicio o blog.

Mucha más información

Si quieres saber alguna cosa más sobre DigitalOcean. Tengo otro tutorial para crear direcciones IP flotantes. Donde explico la utilidad de las mismas y algún ejemplo de uso.

Dudas y comentarios

Puedes dejar tus dudas y comentarios sobre el vídeo tanto en la página de youtube como aquí. Intentaré responderlos todos cuanto antes.

The post ¿Qué es un VPS y cómo crear uno en DigitalOcean? [Vídeo] appeared first on Poesía Binaria.

Telegram desde el terminal en Ubuntu, Linux Mint y derivados. Instalación y uso.

Desde que se montó Ubuntizados, el grupo colaborativo de usuarios de Ubuntu en Telegram, me he vuelto un fiel usuario de Telegram. Actualmente estoy suscrito a varios canales y grupos, y cada vez me gusta mas. Sin embargo tenía algo pendiente, que es utilizar Telegram desde el terminal.

Hace algún tiempo que voy detrás de Telegram Messenger CLI. Telegram Messenger CLI es una interfaz para la línea de comandos de Telegram. Y no tanto por las posibilidades que nos ofrece trabaja desde el terminal, si no también por integrarlo con Nautilus, Nemo y Caja. Igualmente, por la opción de utilizarlo directamente desde Python. Vamos que nos ofrece todo un mundo de posibilidades.

Imagínate (y con esto te puedes hacer una idea de en que estoy trabajando) que puedes enviar documentos o archivos directamente desde Nautilus a Telegram…

Telegram desde el terminal en Ubuntu, Linux Mint y derivados. Instalación y uso. Portada.

Telegram desde el terminal

El uso de Telegram desde el terminal tiene muchas ventajas. Pero desde mi punto de vista, las ventajas vienen de la mano de la automatización.

Me refiero por ejemplo a crear sencillos scripts para enviar archivos a un usuario o chat, o que te avisen de algún evento o situaciones similares. O incluso dar órdenes a tu equipo para que realice determinadas acciones.

¿Que nos permite hacer Telegram desde el terminal?

Existe toda una serie de comandos que seguro nos va a facilitar el uso de Telegram desde el terminal.

Para acceder a la lista de comandos una vez ya estamos ejecutando Telegram desde el terminal, tan solo tenemos que pulsar dos veces el tabulador.

Tampoco es necesario escribir el comando completo o el usuario completo, tan solo tenemos que comenzar a escribirlo y pulsar tabulador para que nos ayude a completarlo.

Así algunos de los comandos mas interesantes soportados, en el momento de escribir este artículo ,son los siguientes:

  • msg <contacto> "Texto". Nos permite enviar un texto a un contacto. Indicar que el Texto debe ir entrecomillado, y que nuestro contacto, en caso de que sea Nombre y Apellido debe figurar como Nombre_Apellido. Es decir, hay que reemplazar el espacio por guión bajo.
  • send_photo <contacto> <nombre-del-archivo> envía una imagen al contacto.
  • send_video <contacto> <nombre-del-archivo> envía un vídeo al contacto.
  • send_text <contacto> <nombre-del-archivo> envía un archivo de texto al contacto.
  • load_photo <msg-numero> descarga una imagen correspondiente al número de mensaje indicado. Empezando por cero la última foto. Esto es completamente independiente del canal, grupo o contacto.
  • load_video <msg-numero> descarga un vídeo correspondiente al número de mensaje indicado.
  • load_document <msg-numero> descarga un documento correspondiente al número de mensaje indicado.
  • searchnos permite buscar entre los mensajes
  • dialog_list muestra la información relativa a los diálogos.
  • contact_list muestra información sobre nuestros contactos.

Instalación

Telegram-Cli no está disponible en los repositorios oficiales de Ubuntu. Sin embargo, dado que me ha parecido realmente interesante lo he empaquetado y lo he añadido al repositorio. De esta forma lo puedes instalar muy fácilmente con ppaurl haciendo clic en telegram-cli. O bien desde el emulador de terminal ejecutando la siguientes órdenes,

sudo add-apt-repository ppa:atareao/telegram
sudo apt update
sudo apt install telegram-cli

Más información,

La entrada Telegram desde el terminal en Ubuntu, Linux Mint y derivados. Instalación y uso. aparece primero en El atareao.

Lunes 17 de abril de 2017

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Temas y plantillas en Hugo – Parte 4

En esta serie de artículos sobre el gestor de contenidos Hugo, vamos a centrarnos en los temas.

En el siguiente enlace podemos ver cientos de ejemplos de temas para Hugo:

http://themes.gohugo.io/

Para instalarlos sólo hay que descargarlos y copiarlos en la carpeta themes de nuestro sitio. Aunque la mayoría de los temas los podemos instalar usando el comando git.

Algunos temas nos van a requerir alguna distribución especial de los contenidos o introducir alguna configuración especial en el sitio. Esto lo podemos ver en las descripciones de los temas.

Los temas se crean a través de las plantillas (Templates) de Hugo. Básicamente una plantilla es un fichero html y en el que vamos a encontrar algunas etiquetas especiales del tipo “{{ algo }}”.

Por ejemplo:

<!DOCTYPE html>
<html>
<head>
  <title>{{ .Title }}</title>
</head>
<body>
  <h1>{{ .Title }}</h1>
  {{ .Content }}
</body>
</html>

Esto es una plantilla html del lenguaje Go. Para ver una introducción a este lenguaje podemos consultar la documentación de Hugo sobre las plantillas:

https://gohugo.io/templates/go-templates/

En el ejemplo anterior, se puede ver que aparece la etiqueta “{{ .Title }}”, que lógicamente se reemplaza por el título cuando el sitio se construye. También tenemos la etiqueta “{{ .Content }}”, que se reemplazará por el contenido.

Temas y layouts

Hay dos carpetas que nos var interesar la carpeta themes y la carpeta layouts. Generalmente layouts estará vacía y cuando se tenga que crear un sitio, se tomarán los archivos de themes y se usará el tema que se haya seleccionado. Puede ocurrir que deseemos que independientemente del tema a utilizar, se use una determinada configuración para la página de inicio (por ejemplo), podemos entonces crear nuestra página de inicio en layouts que se usará independientemente del tema que se vaya a poner por defecto.

Plantillas principales de Hugo

Tenemos la plantillas:

  • Single: Representa cómo se va a dibujar una entrada o un elemento simple de contenidos
  • List: Representa cómo se va a dibujar una lista de contenidos.
  • Homepage: Es la página de inicio de nuestro sitio.

Empecemos por la página de inicio, la vamos a entrar en el directorio “themes/nuestro-tema/index.html”. Probad a editarla y veréis cómo se modifica la página de inicio de vuestro sitio.

Según el tema, también deberéis tocar ciertos parámetros de la configuración para cambiar ciertos elementos del tema.

Pero antes de continuar vamos a ver las posibilidades de las plantillas de Go.

Plantillas de Go

Variables

Hugo usa las plantillas del lenguaje Go para procesar el texto html de forma muy rápida. Como ya se ha dicho, las plantillas van entre los símbolos {{ }}. Así, por ejemplo, para obtener el valor de una variable ya definida se pondría:

<!DOCTYPE html>
<html>
<body>
  {{ variable }}
</body>
</html>

Las variables que define Hugo, se pueden encontrar en:

http://gohugo.io/templates/variables/

Para definir el valor de una variable también se puede usar el símbolo $ delante de la variable:

{{ $variable := "Hola mundo" }}

Después se obtiene su valor:

{{ $variable }}

Hugo también permite usar funciones, las funciones predefinidas se pueden encontrar en:

http://gohugo.io/templates/functions/

Para usar una función simplemente se la llama por su nombre:

{{ función }}

Para pasar argumentos a una función, se ponen los argumentos separados por espacios:

{{ add 1 2}}

La función add suma dos valores, en este caso devolverá 3.

Iteraciones

Las plantillas de Hugo permiten iterar entre los elementos de una array. Para ello se usará “range”. Por ejemplo, para listar todos los elementos de un array:

{{ range $elemento := array }}
    {{ $elemento }}
{{ end }}

Vamos a verlo funcionar, se abre el archivo index.html, dentro de nuestra carpeta themes/tema, e introducimos:

{{ range $pagina := .Data.Pages }}
    Títulos de páginas: {{ $pagina.Title }}<br/>
{{ end }}

Ahora al generar el sitio veremos el contenido que se ha introducido al ejecutar “range”.

Se puede también acceder por contexto:

{{ range array }}
    {{ . }}
{{ end }}

En el ejemplo que estábamos manejando:

{{ range .Data.Pages }}
    Títulos de páginas: {{ .Title }}<br/>
{{ end }}

Por último, se pueden usar mapas, para iterar en el mapa se puede usar la siguiente construcción:

{{range $índice, $elemento := array}}
    {{ $índice }}
    {{ $elemento }}
{{ end }}

En nuestro ejemplo:

{{ range $index, $page := .Paginator.Pages }}
    {{ $index }}
    {{ $page.Title }} <br/>
{{ end }}

Condicionales

La estructura if está soportada por la plantillas de Go. Por ejemplo:

{{ if lt 2 3 }}
    Cierto
{{ end }}

que significa si 2 es menor que 3 escribe “Cierto”.

Disponemos de los comparadores:

  • eq Devuelve verdadero si arg1 == arg2
  • ne Devuelve verdadero si arg1 != arg2
  • lt Devuelve verdadero si arg1 < arg2
  • le Devuelve verdadero si arg1 <= arg2
  • gt Devuelve verdadero si arg1 > arg2
  • ge Devuelve verdadero si arg1 >= arg2

Se puede usar and y or para añadir nuevas condiciones, pero hay que tener en cuenta que en la plantillas de Go los argumentos van siempre detrás de la función:

{{ if and (lt 2 3) (gt 3 2) }}
    Cierto
{{ end }}

Por supuesto, la estructura if-else también se puede usar:

{{ if lt 3 2 }}
    False
{{ else }}
    Cierto
{{ end }}

Else if:

{{ if lt 3 2 }}
    False
{{ else if gt 3 2 }}
    Cierto
{{ end }}

Se puede usar not para negar una condición:

{{ if not lt 3 2 }}
    Cierto
{{ end }}

Contextos

A veces tenemos que hacer referencia a objetos dentro de otros objetos y hay que escribir mucho código. Una forma de hacer esta tarea más cómoda es usando with. En el siguiente ejemplo, cada vez que nos refiramos a . dentro de la estructura with, nos estaremos refiriendo a “.Params.title”:

{{ with .Params.title }}
    <h4>{{ . }}>
{{ end }}

Tuberías

Se tiene algo similar a las tuberías UNIX, por ejemplo, supongamos la siguiente operación matemática:

{{ add 5 (add 3 2) }}

Se podría escribir de la siguiente forma:

{{ add 3 2 | add 5 }}

Como se puede ver el resultado de la suma 3+2 se pasa como último argumento de la siguiente operación “add 5”.

Se pueden encadenar varias tubería:

{{ add 3 2 | add 5 | add 4}}

Uso del operador . en contextos

El operador {{ . }} siempre se refiere al contexto actual. Nos sirve para llamar a variables y a varibles dentro de variables (“.Params.title”). Dentro de un bucle {{ . }} se referirá al valor del elemento actual. Si es necesario acceder al contexto global, se puede usar $., por ejemplo:

{{ range .Data.Pages }}
    Títulos de páginas: {{ .Title }}
    {{ $.Site.Title }} <br/>
{{ end }}

Includes

Se puede incluir un archivo dentro de otro. Por ejemplo, podríamos tener en una archivo la cabecera que queremos que aparezca en todas las páginas web de nuestro sitio. En otro archivo el pie de página. En cada página que escribamos, podemos incluirlos usando:

{{ partial "cabecera" . }}

Texto de la página

{{ partial "pie" . }}

De forma automática Hugo incluirá el pie y la cabecera en la página. Si hacemos una modificación en la cabecera, todas las páginas en las que hayamos incluido la cabecera, recibirán la actualización.

Para incluir archivos podemos usar el comando partial:

{{ partial "archivo" contexto }}

El archivo debe estar localizado en el directorio layout/partials. El contexto se refiere a las variables a las que tendrá acceso el archivo incluido, normalmente acceden a “.”.

Tenemos otra forma de incluir archivos usando template:

{{ template "archivo" contexto }}

La diferencia se encuentra en que el archivo a incluir deberá estar en layout. La documentación de Hugo recomienda usar partial.

Si exploráis los temas de Hugo vais a ver buenos ejemplos del uso de partial.

Existe otra forma de incluir plantillas, la función “.Render”. Para introducir contenidos con “.Render” sólo hay que incluir el nombre de la plantilla a utilizar. Por ejemplo, para ver la plantilla “summary.html”:

{{ .Render "summary"}}

Eliminando espacios en blanco

Imaginad que el comando “.Title” devuelva un título con espacios en blanco y saltos de línea antes y después, por ejemplo:

<h1>{{ .Title }}</h1>

e imaginad que la salida final fuera:

<h1>
    Ejemplo de título
        </h1>

Esta salida no es elegante ni cómoda de leer a la hora de editar código.

Usando el operador {{- -}} se pueden eleminar estos espacios:

<h1>{{- .Title -}}</h1>

La salida final sería:

<h1>Ejemplo de título</h1>

Paso de parámetros a las pantillas

Hugo tiene predefinidas una serie de variables que pueden ser útiles:

http://gohugo.io/templates/variables/

A través de los archivos de configuración o a través de metadatos, se pueden pasar parámetros, definidos por el usuario, a las plantillas. Supongamos que se define la sección params en el archivo “config.toml”. Dentro de esta sección definimos las variables que necesitamos, por ejemplo:

baseurl = "http://localhost:1313"
languageCode = "es"
title = "Ejemplo de nuevo sitio"

[params]
ejemplo = "Ejemplo de valor definido"

Dentro de uno de los archivos del tema podremos introducir:

{{ .Site.Params.Ejemplo }}

y allí obtendremos el valor de la variable.

De forma similar se pueden definir variables en la cabecera de las entradas. Por ejemplo, si se tiene la entrada “hola-mundo.md”, se podría introducir la variable “Fecha”:

+++
date = "2017-04-07T01:04:36+02:00"
title = "hola mundo"
Fecha = true

+++

Hola mundo **esto** es un ejemplo.

Ahora se podría ir a la parte del tema correspondiente y hacer que si Fecha es true, se muestre la fecha de esta entrada:

{{ if .Params.Fecha }}
    {{ .Date.Format .Site.Data.Formats.date }}
{{ end }}

Como se puede ver usando “.Params.parámetro” se puede acceder al valor de la variable.

Para terminar

Hasta aquí esta breve introducción a los temas Hugo. Un par de recomendaciones:

La primera, ver la documentación oficial de Hugo:

https://gohugo.io/templates/go-templates/

Por otro lado es bueno bajarse un tema y explorarlo y modificarlo. Veremos que se usan cosas como “.Render” que llama a alguna plantilla para mostrar los contenidos. Para no volvernos locos buscando los archivos se recomenda usar los comandos de UNIX grep y find:

Con grep buscaremos los archivos que contengan algún tipo de texto que nos interese:

grep -Re 'texto a buscar'

Por otro lado find nos ayuda a buscar archivos por su nombre:

find . -name "nombre del archivo"

En el nombre del archivo se pueden introducir wildchars como son el * y la ? que nos ayudan a buscar los archivos de forma más cómoda.


Lunes 10 de abril de 2017

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Resolviendo el problema de los acentos y las eñes que de repente dejan de funcionar

¿Alguna vez os ha pasado que estabais escribiendo algo en vuestro Linux y los acentos han dejado de funcionar? Pues tiene solución y es sencilla, se llama ibus.

En Ubuntu sólo tenemos que ir a “Configuración del sistema/Soporte de Idiomas” y seleccionar en “Sistema de método de entrada de teclado” la opción ibus. Reiniciamos y… problema resuelto.

¿Y si no tengo esta ventana? Por ejemplo, estoy usando un escritorio LXDE con lo mínimo instalado. Entonces hay que instalar ibus:

sudo apt install ibus

Una vez instalado con la herramienta ibus-setup, lo podemos configurar:

Captura de pantalla de 2017-04-09 17-03-22

Fin.


Domingo 09 de abril de 2017

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Contenidos en Hugo – Parte 3

En esta serie de artículos sobre el gestor de contenidos Hugo, vamos a centrarnos en la creación de los contenidos.

Con el comando:

hugo new

Se pueden introducir nuevas entradas en nuestro sitio web. Por ejemplo:

hugo new eldiario/noticia1.md

Dentro del directorio content, se habrá creado una carpeta llamada “eldiario” y allí dentro un archivo con la extensión “md”, “noticia1.md”.

Ahora con:

hugo new eldiario/noticia2.md

Dentro del directorio eldiario/noticia se habrá creado “noticia2.md”.

Si ahora con el comando:

hugo server --theme=hugo_theme_robust -Dv

Visitamos el sitio web creado, se puede comprobar que aparecen noticia1 y noticia2, y a cada una se les ha asignado la etiqueta “eldiario” (que coincide con el nombre del directorio). Si se hace clic sobre el nombre de la etiqueta, nos mostrará todas las noticias que tengan asignada esta etiqueta (notica1 y noticia2).

Si las comparamos con las taxonomías, en las taxonomías se creaba un menú con las etiquetas que se habían introducido. En el caso de las etiquetas no.

Vamos ahora a introducir una imagen en una de las entradas que hemos creado. Las imágenes las podemos poner en 2 lugares:

  • En la carpeta en la que se introduce la entrada.
  • En la carpeta static.

Por ejemplo, creamos una entrada nueva:

hugo new noticia/noticia1.md

Se creará la carpeta “content/noticia” y dentro de ésta “noticia1.md”.

Ahora ponemos una imagen en “content/notica”, por ejemplo, “imagen1.png”. Si queremos hacer que esta imagen aparezca en la noticia, en el texto de la noticia deberemos poner:


+++
date = "2017-04-09T15:35:01+02:00"
draft = true
title = "noticia1"

+++

En formato markdown
![Esto es una imagen](../imagen.png)

En formato html:
<img src='../imagen.png' />

Si nos fijamos, la referencia a la imagen la hacemos a la carpeta anterior “../imagen.png”.

Si ahora, la imagen la ponemos en la carpeta static, la referencia deberá ser:


+++
date = "2017-04-09T15:35:01+02:00"
draft = true
title = "noticia1"

+++

En formato markdown
![Esto es una imagen](/imagen.png)

En formato html:
<img src='/imagen.png' />

Es decir a “/imagen.png”, los contenidos de static se copian directamente a la raíz del sitio web.

Por último, si en static creamos la carpeta “img” y ponemos la imagen en “static/img”, deberemos poner:


+++
date = "2017-04-09T15:35:01+02:00"
draft = true
title = "noticia1"

+++

En formato markdown
![Esto es una imagen](/img/imagen.png)

En formato html:
<img src='/img/imagen.png' />

Es decir, en la raíz del sitio web se va crear la carpeta “/img” y dentro de ella se copiará la imagen.

Algunos temas soportan imágenes en las cabeceras de las noticias, para ello usamos el parámetro thumbnail en la cabecera del documento:

+++
date = "2017-04-09T15:35:01+02:00"
draft = true
title = "noticia1"
thumbnail = "/imagen.png"

+++

Esta es la noticia 1.

Por último, vamos a dar un repaso a los directorios que se crean cuando se ejecuta el comando “hugo new site” para crear un sitio nuevo:

  • archetypes: Cuando se crea un nuevo contenido con el comando “hugo new”, se añaden al artículo algunas configuraciones por defecto, como el título o la fecha. Aquí se pueden definir las configuraciones por defecto que se van a colocar.
  • config.toml: Es el archivo de configuración del sitio web. Usa el lenguaje TOML, aunque se pueden usar otros como JSON o YAML. En él se definen cosas como el nombre del sitio, el idioma, la URL.
  • content: Aquí se almacenan los contenidos que el usuario almacena en el sitio.
  • data: Se usa para almacenar la configuración que Hugo usa para generar el sitio web.
  • layouts: Indica la forma en la que los contenidos van a ser transformados en un sitio estático.
  • static: Lo podemos usar para almacenar todos los contenidos estáticos del sitio, como imágenes, Javascript, CSS, imágenes,… El contenido se copiará a la raíz del sitio.
  • themes: Son los temas que definen la apariencia que va a tener el sitio web. Se pueden crear e instalar varios temas y cambiar de uno a otro. Hay muchos temas disponibles para ser descargados y modificados.

Jueves 06 de abril de 2017

José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

Problemas de postgrey y las listas grises con los servidores de correo de outlook y hotmail de Microsoft

correo Hace ya años que contamos por aquí en que consisten las listas grises a la hora de validar como bueno un correo y combatir contra el spam y enseñamos a configurarlas en un servidor con Debian y postfix. Recientemente he tenido muchos problemas con los correos que vienen de servidores de Microsoft (¡como no!) que provocaban retrasos de hasta algunos días o pérdida de correos en algunas ocasiones. Vamos a contar que es lo que ocurre y como solucionarlo.

El problema que tenemos con los servidores de correo de Microsoft es que el reintento de envío del correo que exige el sistema de listas grises no se realiza desde el mismo servidor que realiza el envío original con lo que nuestro sevidor toma el reintento como un correo diferente al original y no lo valida como correcto. La solución es fácil y seguramente estará “parcheada” en un futuro en nuestras Debian, pero por el momento tienes que solucionarla por ti mismo. Vamos a verlo.

En el directorio /etc/postgrey tenemos dos ficheros: whitelist_clients y whitelist_recipients. En ellos podemos incluir manualmente los servidores y direcciones de correo (respectivamente) que queremos validar automáticamente sin pasar por el sistema de listas grises. No obstante, hacerlo es una mala idea: en estos ficheros (sobre todo en el primero) es donde los mantenedores de Debian incluyen los servidores de correo que ya saben que dan problemas con el sistema de listas grises pero son servidores válidos. Posiblemente nuestro problema se resolverá en un futuro próximo cuando la gente de Debian incluya los servidores de Microsoft en este fichero pero mientras tanto tenemos que buscarnos una solución. Postgrey admite incluir en este mismo directorio dos nuevos ficheros con la misma funcionalidad pero donde podamos incluir nuestros propios servidores y direcciones de correo sin miedo a perder actualizaciones: whitelist_clients.local y whitelist_recipients.local.

Ahora ya sólo nos hace falta saber cuales son las direcciones de los servidores de correo de Microsoft. Afortunadamente están casi todas publicadas aquí. En algún foro he leído que es interesante añadir un par de líneas adicionales para validar los servidores de los servidores de Office 365. Al final, mi fichero whitelist_clients.local ha quedado así:

23.103.132.0/22
23.103.136.0/21
23.103.144.0/20
23.103.156.0/22
23.103.191.0/24
23.103.198.0/23
23.103.198.0/24
23.103.199.0/24
23.103.200.0/22
23.103.212.0/22
40.92.0.0/14
40.107.0.0/17
40.107.128.0/18
52.100.0.0/14
65.55.88.0/24
65.55.169.0/24
94.245.120.64/26
104.47.0.0/17
104.212.58.0/23
134.170.132.0/24
134.170.140.0/24
157.55.234.0/24
157.56.110.0/23
157.56.112.0/24
207.46.51.64/26
207.46.100.0/24
207.46.163.0/24
213.199.154.0/24
213.199.180.128/26
216.32.180.0/23
2a01:111:f400:7c00::/54
2a01:111:f403::/48
104.47.0.0/17
40.107.0.0/16
/.*outbound.protection.outlook.com$/
/outlook/

Ahora sólo queda reiniciar los daemons de postgrey y postfix para que los cambios tomen efecto y listo

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: Problemas de postgrey y las listas grises con los servidores de correo de outlook y hotmail de Microsoft || Hospedado en un Cloud VPS de Gigas.

Miércoles 22 de marzo de 2017

BlogDRAKE: La magia sigue viva

Lunes 20 de marzo de 2017

BlogDRAKE: 3 de mis imagenes estaran en Mageia 6

Lunes 13 de marzo de 2017

Guillermo Garron

Guillermo Garron
GNU Linux

{{ post.title }}

{{ post.content | xml_escape }}
Juanje Ojeda

Juanje Ojeda
Nada de particular

Cambio de profesión

El 8 de noviembre del año pasado cumplí 38 años y me siento mejor de lo que me sentía con 20, así que estoy muy contento :-)

Además, celebré mi cumpleaños regalándome un cambio de profesión. He vuelto a una de mis 2 grandes pasiones, el cuerpo humano y la educación física.

Después de estar un tiempo reciclándome (hace 15 años que estudié Ciencias de la Actividad Física y del Deporte y han cambiado muchas cosas desde entonces...) y dedicándome a mejorar mi salud, me decidí a tirarme a la piscina y dejar los ordenadores para dedicarme a las personas.

Hacía mucho que no estaba tan motivado con algo :-)

Ya llevo casi un año metido en esa aventura y cada día más motivado. Aprendo mucho cada día e intento compartir ese conocimiento en mi nuevo blog profesional:
Juanje Ojeda

La mayoría de mis clientes son personas con mi antiguo perfil. Personas sedentarias que trabajan todo el día con ordenadores y que les cuesta encontrar tiempo y fuerza de voluntad para tomar las riendas de su salud.
Incluso he empezado a ayudar de forma remota a antiguos compañeros de trabajo y gente del gremio. Es lo bueno de Internet y las nuevas tecnologías :-P
Entrenamiento online

Espero seguir así de contento e ilusionado con esta nueva etapa durante mucho tiempo. Pero si no es así, al menos lo intenté y lo disfrutaré mientras dure :-)
Juanje Ojeda

Juanje Ojeda
Nada de particular

Nace ASOLIF. Una apuesta de futuro y colaboración

Copio el anuncio que hizo el amigo Agustín sobre el nacimiento de la asociación de empresas de software libre federadadas (ASOLIF) en la lista de socios de Hispalinux, que el lo explica mejor de lo que lo haría yo ;-)

Ayer precisamente vi a Gonzalo (Fotón), que venía de la firma de la misma y que venía muy animado y esperanzado con el proyecto. Más tarde se nos unió Victor Fernandez (gerente, socio y amigo de Emergya) y tuvimos una cena muy agradable con tapitas y cervezas en la que hablamos de ASOLIF, los diferentes modelos de negocio y enfoques de las empresas que producen y consumen software libre, y más temas relacionados y muy interesantes.
Fué un debate intenso, interesante y muy constructivo. Que es lo más importante. Exponer opiniones, argumentarlas y sacar lo mejor de cada una de ellas para mejorar y avanzar.

Bueno, no me enrollo más, les dejo el mensaje de Agustín, para que aquellos que no están en la lista, puedan enterarse de esta interesante y prometedora noticia.

-----Original Message-----
From: Agustín Benito Bethencourt

Date: Fri, 29 Feb 2008 16:25:46
To:socios EN hispalinux PUNTO es
Subject: [Socios-HispaLinux] nace asolif


Hola a todos,

me congratulo en comentar que hoy nace oficialmente ASOLIF, la asociación de
empresas de software libre federadas. Forman parte de ella inicialmente las
asociaciones regionales ESLIC (Canarias), ESLE (País Vasco) y CatPL
(Cataluña). La inauguración ha sido auspiciada por el CENATIC esta mañana.

Como miembro fundador (y de la actual Junta Directiva) de ESLIC, quiero
decirles que se trata de una iniciativa que ha costado un año llevar adelante
y que esperamos todos sea la chispa que nos permita a las empresas de
software libre disponer de un foro efectivo, donde poder conectarnos formando
una red de empresas que den soporte e impulsen el software libre a nivel
empresarial en nuestro pais. El software libre SI tiene quien lo soporte en
España.

Sé que hay muchos empresarios que pertenecen a Hispalinux y sé que la propia
asociación ha servidor muchas veces como vehículo de nuestras demandas e
inquietudes. Sólo espero que la colaboración entre Hispalinux y la nueva
Federación sea lo más fructífera posible. Nos necesitamos.

Si eres profesional o empresa, permíteme invitarte a moverte para formar una
asociación de empresas en tu Comunidad (hay algunas que lo están haciendo ya)
y pasar a formar parte de esta Federación. Debemos estar todos para que el
esfuerzo que hemos puesto en esto tenga sentido.

Saludos
--
Agustín Benito Bethencourt
Grupo CPD
abenito @ grupocpd.com
http://www.grupocpd.com
http://agustin.ejerciciosresueltos.com
http://www.toscalix.blogspot.com
_______________________________________________


IMPORTANTE: Los mensajes y opiniones que aparecen en esta lista son de la exclusiva responsabilidad de sus autores. No son atribuibles a Hispalinux ni a los gestores de la lista.
-----Original Message-----


A ver qué tal va este asunto. ¡Mucha suerte a todos! :-)



Juanje Ojeda

Juanje Ojeda
Nada de particular

Sobre la BlackBerry desde la BlackBerry (III)

Lo prometido es deuda, aquí tienen el listado de mis aplicaciones favoritas para la BlackBerry.

He buscado cosas libres, pero es complicado encontrarlas. En su defecto he encontrado aplicaciones gratuitas. No es lo mismo, pero siendo prácticos, me sirven.

Listaré las aplicaciones por funcionalidad:


Y algunas aplicaciones vía web o wap:

¿Qué es lo que más uso yo? Pues después de probar mucho y pasarseme algo de la novedad lo que realmente uso y me resulta bastante práctico es:
(ordenado por frecuencia de uso)


Por cierto, el Opera Mini está muy bien, pero tiene algunas cosas que no terminan de gustarme y no se integra bien con la Perla. El trackball no funciona como esperas y no te deja ir a un enlace directamente con él, tienes que dar dos pasos...
Menú -> Selecionar

Usabilidad: -10 :-(

Una pena porque en cuanto a rapidez de carga y formateo de páginas es genial.

Otro día una escribo una revisión a algunas de estás webs o aplicaciones que uso. Pero espero que esta pequeña relación de enlaces le resulte útil a más de uno. A mí tener algo así me hubiera ahorrado bastante tiempo...
Otra cosa de la que me gustaría hablar es sobre el PIN. Si alguien tiene información útil e interesante sobre el tema, que lo diga, así me documento mejor del tema ;-)


Viernes 10 de marzo de 2017

BlogDRAKE: Humor: La comunidad en estos momentos 2
José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

Chuletillas (y XXXXVII) – Instalar un programa de debian Stretch mientras que usas debian stable (Jessie)

chuletaSi quieres instalar un determinado programa (y sus dependencias obligatorias) incluido en la próxima versión de Debian (Stretch) mientras continuas usando la versión stable (Jessie) puedes hacerlo de la siguiente forma:

En primer lugar edita tu fichero sources.list (en el directorio /etc/apt) e incluye al final las direcciones de los repositorios de Stretch pero sin eliminar ni modificar los que ya usas de Jessie. Por ejemplo así:

# Repositorios de Jessie
deb http://http.debian.net/debian/ jessie main contrib non-free
deb-src http://http.debian.net/debian/ jessie main contrib non-free
deb http://security.debian.org/ jessie/updates main contrib non-free
deb-src http://security.debian.org/ jessie/updates main contrib non-free

# Updates de Jessie, antes conocidos como 'volatile'
deb http://http.debian.net/debian/ jessie-updates main contrib non-free
deb-src http://http.debian.net/debian/ jessie-updates main contrib non-free

# Backports de Jessie
deb http://http.debian.net/debian jessie-backports main contrib non-free

#Repositorios de Stretch
deb http://http.debian.net/debian/ stretch main contrib non-free
deb-src http://http.debian.net/debian/ stretch main contrib non-free
deb http://security.debian.org/ stretch/updates main contrib non-free
deb-src http://security.debian.org/ stretch/updates main contrib non-free

# Updates de Stretch
deb http://http.debian.net/debian/ stretch-updates main contrib non-free
deb-src http://http.debian.net/debian/ stretch-updates main contrib non-free

A continuación creamos un fichero llamado stretch en el directorio /etc/apt/preferences.d y escribimos en el lo siguiente:

Package: *
Pin: release n=jessie
Pin-Priority: 900

Package: *
Pin: release n=stretch
Pin-Priority: 100

Con esto estamos modificando la prioridad con la que Debian actualizará nuestros paquetes. Por defecto instala siempre la versión más moderna de todas las que tenga disponibles en sus repositorios. Con este fichero le dará preferencia a cualquier paquete de jessie frente a uno de stretch aunque tenga una versión menor. Es decir, mantendremos nuestro sistema con las versiones de jessie salvo que un paquete no exista en esta y si en stretch… O se lo indiquemos manualmente durante la instalación que es lo que vamos a ver a continuación. Si quieres maś información sobre la forma de establecer preferencia para apt puedes echarle un vistazo a esta página.

Y ya lo tenemos todo listo. Ahora, tenemos que actualizar nuestros repositorios (apt update) y cuando queramos instalar un paquete directamente de stretch lo especificamos manualmente en el comando apt. Por ejemplo, si quisiéramos instalar la versión de apache de stretch lo haríamos así:

apt-get install -t stretch apache2

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: Chuletillas (y XXXXVII) – Instalar un programa de debian Stretch mientras que usas debian stable (Jessie) || Hospedado en un Cloud VPS de Gigas.

Jueves 02 de marzo de 2017

José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

Nueva página: Herramientas web de testing y monitorización

herramientas En muchos de los articulos que publico por aquí referencio herramientas web encaminadas a ayudar con la configuración, pruebas o análisis de diversos elementos de nuestra infraestructura informática. Servidores Web, certificados SSL, Disponibilidad, Correo Electrónico, Seguridad, etc. El enlace a la página está en el índice lateral y aquí:

Herramientas web de Testing y Monitorización

El propósito de esta nueva página es recogerlas en un único lugar para mantener una referencia completa, cómoda y perfectamente autorizada. Todas las herramientas relacionadas en ella son gratuitas al menos en un modo básico aunque podrían tener un modo de pago más completo. Y si conoces alguna otra que no aparece y crees que puede ser útil no dejes de enviármela a través de un comentario por favor. Gracias.

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: Nueva página: Herramientas web de testing y monitorización || Hospedado en un Cloud VPS de Gigas.

Domingo 19 de febrero de 2017

Marcelo Fortino

Marcelo Fortino
Fortinux

Tutorial Instalar PHP Server Monitor en Ubuntu GNU/Linux

En este tutorial vamos a instalar PHP Server Monitor en un servidor Ubuntu 14.04. PHP Server Monitor es una aplicación web open source que sirve para monitorear servidores web y/o sitios web.

Martes 07 de febrero de 2017

Ramón Miranda

Ramón Miranda
Ramon Miranda

TRUN videogame cover for VGsource


Talking about TRON is talking about a classic science fiction film and one of the best tributes to creativity and imagination in the world of cinema. Somewhat misunderstood film at first, but time makes justice and put TRON in its place. And if we talk about mythical elements of the film, we have to talk about bikelight racings ...

TRUN is a videogame created in Z80 assembler based on  original TRON.
The creators of the game are Vgsource, an indie development group that codes for MSX.
A few months ago, I was contacted to design their videogame cover and thus give it a greater visual impact.
It was an interesting work because from the first moment we looked for a 80's look"  immitating the style of covers of the era of Dinamic or Topo (spanish companies), where Azpiri was king illustrating those beautiful casettes and the less important was the result on screen (at least for people like me)
The first thing I did was to take references, and as it was not going to be otherwise the TRON movie itself was the main source of inspiration. I had several keys in mind while painting this illustration:
  •     blue
  •     Light
  •     No Fx overlay.
  •     Speed
  •     80's smell
Do you want to see how development was? Then we analyze the different phases briefly.

Sketches Phase

After analyzing what I want to emphasize in the image I start working on the sketches.
These are not very detailed drawings, but you can see the main elements of the design.


I decide for the first by movement feeling.



As we know the diagonals add movement to the composition and as I want to transmit speed I choose the design with that scheme and the broad to be able to study where to place each thing. Something that in the end I will change are the bikes. Finally will be even more "homage" to the original light bikes designed by Syd Mead.

References Phase

Being the game a "clone" of the game of TRON does not seem crazy to me to take references of the film. Since we are going to make a copy of a classic we will do well. Let it be noticed! That's why I create a composition with multiple references to then paint over what I need and get the result I want, not so photo but 2d. There is still a lot of work left. This system is not the only one I use for my illustrations.
This is the result of collage done inside Krita. All images have their corresponding copyright. We only use this as an idea. At the end, 100% of the illustration is repainted.



From this point we will work the Backgrounds. For the backgrounds, brushes that are quick for "covering big areas" are usually used. I use a brush that has the characteristic that diffuses the paint when low pressure is used and is adding more paint as the pressure increases. This is what I show you in the capture.




It has a Knive effect and belongs to the set I made for the DVD of the krita foundation #muses. If you are interested you can download it here totally free.

PACK bundle muses

Note: If for some reason you see that this brush produces somekind of "Lag", a very useful thing that speed up this brush and many of Krita's brushes is to use the "precision" parameter inside the brush editor and lower it from 5 to 1 If you also use large sizes you can increase the brush spacing to 0.5 or 0.7. It can be further optimized to gain speed in very large sizes.




Beyond it you will see that it is very fluid but loses a little of quality. These brushes require important computation operations for the CPU but give very interesting results.
What I want is to blur the photo effect but respecting the colors that are underneath while still being spots and at the same time giving me more freedom to paint over. You will see that the result is very pictorial. Handcrafted within the digital.

 
Now it's time to start defining all the elements of the image.
The face in the photo does not show an emotion according to what I look for, come on man! You're playing with your life in a race! :)
I have created this Gif for those who like to follow the evolution of the steps to follow.


You can see how the lighting changes as I work the metal. The gif was done with Gimp. It explains much more than a page of text. Among other things it is seen how the light is affecting the face of the character and his helmet.

The same thing happens in the background. When I go detailing the bikes and the kind of hangar where they come from.

When completing the image we run the risk of adding too many details. So beware of the Glow and the additive or color dodge modes that hook.
Making lines or curves accurately is complicated with freehand so one way to avoid headaches is to use paint assistants.

For example a use would be in the curve that defines the motorcycle panel of the character.


LightBykes

A main element of this image are the light bikes. Let's do something simple so we do not separate too much from what will be seen on the screen.


 

The problem as I see it is that the bikes need some lines of movement. This will convey more sense of career. In the end I choose lines not on the whole bike but in part. The result is something more shocking.


Logotype design for the cover

All we have left to do is create a logo for the cover design. For that task I better use an image editor like Gimp and a vector design program like Inkscape.

In Gimp I select the text tool with the previously downloaded typography that is very similar to TRON.


To vary slightly the layout i adjust and complete the contour of the word "TRUN" That way I have a good basis for editing in Inkscape and that can be adapted to any size without loss of quality.


Now we can add the text to our image.
And the end result is what we expected. Did you like it?

** If you liked the article and learned something to help you, you can support me by sharing the news with your friends. See you in the next article.

If you want to know more about the video game these links may seem interesting.


Some photos

Asociación de amigos del MSX




https://www.msx.org/es/news/software/es/trun-nuevo-juego-de-msx
 



Ramón Miranda

Ramón Miranda
Ramon Miranda

Portada para videojuego TRUN de VGsource


Hablar de TRON es hablar de un clásico de la ciencia ficción y de uno de los mejores tributos a la creatividad e imaginación en el mundo del cine. Película un tanto incomprendida al inicio, pero el tiempo le dio la razón y la puso en su lugar. Y si hablamos de elementos míticos de la película, tenemos que hablar de las carreras de motos de luz...

TRUN es un videojuego creado en ensamblador Z80 basado en TRON.
Los creadores del Juego son Vgsource, un grupo indie de desarrollo que programa para MSX.
Hace unos meses, me contactaron para diseñar su portada y así darle un impacto visual mayor.
Fue un trabajo interesante porque desde el primer momento se buscaba un "look" ochentero imitando el estilo de portadas de la época de Dinamic o Topo, donde Azpiri era el rey ilustrando esos bellos casettes y lo de menos era el resultado en pantalla ( al menos para personas como yo)
Lo primero que hice fue coger referencias, y como no iba a ser de otra forma la propia película de TRON fue la principal fuente de inspiración. Tenía varias claves en mente mientras pintaba esta ilustración:
  • Azul
  • Luz
  • No Fx overlay.
  • Velocidad
  • Espíritu 80's
¿Os apetece ver como fue el desarrollo? Pues analizamos las diferentes fases brevemente.

    Fase de Bocetos

    Después de analizar qué quiero destacar en la imagen empiezo a trabajar en los bocetos.
    Estos son dibujos no muy detallados en los que se pueden ver los elementos principales del diseño.



    Me decido por la primera por la sensación de movimiento.



    Como ya sabemos las diagonales añaden movimiento a la composición y como quiero transmitir velocidad elijo el diseño con ese esquema y lo amplio para poder estudiar dónde colocar cada cosa. Algo que al final voy a cambiar son las motos. Finalmente serán aun más “homenaje” a las originales motos de luz diseñadas por Syd Mead.

    Fase de referencias

    Siendo el juego un calco del juego de TRON no me parece una locura coger referencias de la película. Ya que vamos a hacer una copia de un clásico vamos a hacerlo bien. ¡Que se note! Por eso creo una composición con las múltiples referencias para luego pintar por encima lo que necesite y llegar al resultado que quiero, no tan foto sino más 2d. Queda aun mucho trabajo.Este sistema no es el único que uso para mis ilustraciones.

    Este es el resultado del collage realizado dentro de Krita. Todas las imágenes tienen sus derechos de autor correspondientes. Esto solo lo usamos como idea. Al final se repinta el 100% de la ilustración.



    A partir de este punto vamos a trabajar los fondos. Para los fondos normalmente se usan pinceles que sean rápidos que "cubran" Utilizo un pincel que tiene la característica que difumina la pintura cuando se ejerce poca presión y va añadiendo más pintura según aumenta la presión. Es este que os muestro en la captura.



    Tiene un efecto como de espátula y pertenece al set que hice para el DVD de la krita foundation #muses. Si os interesa os lo podéis descargar aquí totalmente gratis.

    PACK bundle muses

    Nota: Si por alguna razón veis que este pincel produce algo de "Lag", una cosa muy útil que acelera tanto este pincel como muchos de los de Krita es utilizar el parámetro "precisión" dentro del editor de pinceles y bajarlo de 5 a 1. Si además utilizas tamaños grandes puedes aumentar el espaciado del pincel hasta 0.5 o 0.7. Se puede optimizar aun más para ganar velocidad en tamaños muy grandes.




    Más allá verás que va muy fluido pero pierde un poco de calidad. Estos pinceles exigen operaciones de cómputo importantes para la CPU pero dan resultados muyyy interesantes.  

    Lo que quiero es desdibujar el efecto foto pero respetando los colores que hay debajo aun siendo manchas  y a la vez darme más libertad para pintar por encima. Veréis que el resultado es muy pictórico. Artesanal dentro de lo digital.


     

    Ahora es tiempo de empezar a definir todos los elementos de la imagen.

    La cara en la foto no muestra una emoción acorde a lo que busco, vamos hombre! ¡Que te estás jugando la vida en una carrera! :)

    He creado este Gif para los que les gusta seguir una evolución de los pasos a seguir.

    Se puede apreciar como va cambiando la iluminación según voy trabajando el metal. El gif lo hice con Gimp. Explica mucho más que una página de texto. Entre otras cosas se ve cómo la luz va afectandola cara del personaje y su casco.
    Lo mismo sucede en el fondo. Cuando voy detallando las motos y la especie de hangar de donde salen.


    Al ir completando la imagen corremos el riesgo de añadir demasiados detalles. Así que cuidado con el Glow y los modos aditivos o color dodge que enganchan.
    Hacer lineas o curvas con precisión es complicado a mano alzada por eso una forma de evitarnos quebraderos de cabeza es utilizar los asistentes de pintura.



    Por ejemplo un uso sería en la curva que define el panel de la moto del personaje.


    Motos de Luz.

    Un elemento principal de esta imagen son las motos de Luz. Vamos a hacer algo sencillo para no separarnos demasiado de lo que se verá en pantalla.

     

    El problema según veo es que las motos necesitan unas lineas de movimiento. Esto va a transmitir más sensación de carrera. Al final opto por lineas no en toda la moto sino en parte. El resultado es algo más impactante.


    Diseño de Logo para la portada

    Ya solo nos queda realizar un logotipo para el diseño de la portada. Para esa tarea mejor utilizo un editor de imágenes como Gimp y un programa de diseño vectorial como Inkscape.

    En Gimp selecciono la herramienta texto con la tipografía previamente descargada que es muy parecida a la de TRON.



    Para variar un poco el diseño ajusto y completo el contorno de la palabra TRUN De esa forma ya tengo una buena base para editarlo en Inkscape y que se pueda adaptar a cualquier tamaño sin perdida de calidad.

    Ahora ya podemos añadir el texto a nuestra imagen.
    Y el resultado final es lo que esperábamos . ¿Os ha gustado?
    **Si te ha gustado el artículo y has aprendido algo que te ayude, puedes apoyarme compartiendo la noticia con tus amigos. Nos vemos en el próximo artículo.
    Si quieres saber más del video juego estos enlaces te pueden parecer interesantes.

    Algunas fotos

    Asociación de amigos del MSX


    https://www.msx.org/es/news/software/es/trun-nuevo-juego-de-msx
     




    Sábado 21 de enero de 2017

    Ramón Miranda

    Ramón Miranda
    Ramon Miranda

    Underwater Romance


    Hola a todos mis lectores y colegas. Se fue el 2016, y el 2017 ya lo tenemos aquí.
    Este pequeño artículo es de esos momentos en los que uno hace balance de cómo le fue el año y se pone nuevas metas.Para mi ha sido espectacular. Lo más importante es que al fin di el sí quiero con la mujer que amo. Se llama Lara y es parte fundamental de que esté aquí en Málaga, en esta tierra de luz y color donde tantas veces veranee de pequeño. Nos casamos de manera discreta y sin mucho ruido como queríamos que fuera. Así que en estos momentos estoy muy feliz. Quizás algún día asome por el blog, aunque de momento os digo que no tiene nada que ver con el mundo de la imagen.

    Ya metidos en materia también es muy destacable toda la evolución que ha habido dentro del mundo Krita. Increíble trabajo el de los desarrolladores. Una de las imágenes que la fundación decidió utilizar, fue esta que publico la cual pinté exclusivamente para ellos como recompensa para los que apoyaron la campaña de Kickstarter de Krita en este año. Este es el resultado de apoyar a Krita. la recompensa de ver cómo mejora cada día y ver que más usuarios puedan aprender desentrañando la imagen en alta resolución viendo todas las capas correctamente nombradas. Si quieres apoyar para que el proyecto sea aun mas grande aquí tienes un link https://krita.org/en/support-us/donations/




    Cabe destacar que la idea de hacer la ilustración como vista en el fondo del mar, se le ocurrió a mi mujer tras ver lo que estaba haciendo y los colores que estaba usando. 

    La cara de ella quizás ha sido la parte más difícil. 3 veces la repetí hasta dar con el gesto que buscaba, una pose de inocencia y a la vez de "me dejo seducir por este guapo sireno" ;D



    Si os gusta el resultado seguro que vais a disfrutar con el próximo artículo donde explicaré cómo se hizo esta imagen desde el boceto de color a la pintura acabada.

    Nos leemos






    English Readers

    Hello to all my readers and colleagues. 2016 has gone, and 2017 is already here

    This small article is one of those moments in which you think about how the year went and set new goals. For me it has been spectacular. The most important thing is that finally! I said "yes, i do" to the woman I love. Her name is Lara and she is a fundamental part for being here in Malaga, in this land of light and color where i spent so many summers as a child. We married discreetly and without too much noise as we wanted it to be. So right now I'm very happy. Maybe someday she will write something here, for now I swear you she has nothing to do with the world of the image. :D

    Talking about the picture... is also very remarkable all the evolution that has been in the Krita world. Incredible work for the developers. One of the images that the foundation decided to use, was this one that I published exclusively for them as a reward for those who supported Krita's Kickstarter campaign this year. The bakers with 50$ baked if i remember well received the image in high res and .kra format to learn more about how to use krita. If you want to support krita more there you have a link https://krita.org/en/support-us/donations/



    It is noteworthy that the idea of ​​making the illustration as seen on the bottom of the sea, occurred to my wife after seeing what i was doing and the colors i was putting on canvas.

    Mermaid's face has been the hardest part. I repeated 3 times until I found the gesture I was looking for, a pose of innocence and at the same time "I let myself be seduced by this handsome siren";D





    If you like the result you will enjoy with the next article where I will explain how this image was made from the color sketch to the finished painting.









    Domingo 08 de enero de 2017

    David Moreno

    David Moreno
    dm's blog

    Thanks Debian

    I sent this email to debian-private a few days ago, on the 10th anniversary of my Debian account creation:

    Date: Fri, 14 Aug 2015 19:37:20 +0200
    From: David Moreno 
    To: debian-private@lists.debian.org
    Subject: Retiring from Debian
    User-Agent: Mutt/1.5.23 (2014-03-12)
    
    [-- PGP output follows (current time: Sun 23 Aug 2015 06:18:36 PM CEST) --]
    gpg: Signature made Fri 14 Aug 2015 07:37:20 PM CEST using RSA key ID 4DADEC2F
    gpg: Good signature from "David Moreno "
    gpg:                 aka "David Moreno "
    gpg:                 aka "David Moreno (1984-08-08) "
    [-- End of PGP output --]
    
    [-- The following data is signed --]
    
    Hi,
    
    Ten years ago today (2005-08-14) my account was created:
    
    https://nm.debian.org/public/person/damog
    
    Today, I don't feel like Debian represents me and neither do I represent the
    project anymore.
    
    I had tried over the last couple of years to retake my involvement but lack of
    motivation and time always got on the way, so the right thing to do for me is
    to officially retire and gtfo.
    
    I certainly learned a bunch from dozens of Debian people over these many years,
    and I'm nothing but grateful with all of them; I will for sure carry the project
    close to my heart — as I carry it with the Debian swirl I still have tattooed
    on my back ;)
    
    http://damog.net/blog/2005/06/29/debian-tattoo/
    
    I have three packages left that have not been updated in forever and you can
    consider orphaned now: gcolor2, libperl6-say-perl and libxml-treepp-perl.
    
    With all best wishes,
    David Moreno.
    http://damog.net/
    
    
    [-- End of signed data --]
    

    I received a couple of questions about my decision here. I basically don’t feel like Debian represents my interests and neither do I represent the project – this doesn’t mean I don’t believe in free software, to the contrary. I think some of the best software advancements we’ve made as society are thanks to it. I don’t necessarily believe on how the project has evolved itself, whether that has been the right way, to regain relevancy and dominance, and if it’s remained primarily a way to feed dogmatism versus pragmatism. This is the perfect example of a tragic consequence. I was very happy to learn that the current Debian Conference being held in Germany got the highest attendance ever, hopefully that can be utilized in a significant and useful way.

    Regardless, my contributions to Debian were never noteworthy so it’s also not that big of a deal. I just need to close cycles myself and move forward, and the ten year anniversary looked like a significant mark for that.

    Poke me in case you wanna discuss some more. I’ll always be happy to. Specially over beer :)

    Peace.

    Miércoles 21 de diciembre de 2016

    Juanjo Amor

    Juanjo Amor
    DrAmor's Blog

    Acabemos con los intersticiales

    ¡Interstitials!

    Vaya palabro. “Interstitials”. Intersticiales en español. Anuncios intersticiales; que para la RAE serían aquellos que ocupan los intersticios, pero que, realmente, son anuncios que ocupan toda la pantalla y son especialmente molestos porque,

    • Impiden visualizar la página que queremos ver. Vamos, que molestan, y mucho más, que los pop-ups de toda la vida.
    • Incitan al click fraudulento: La mayor parte de las veces que pulsamos sobre el anuncio, no es para acceder al producto anunciado sino para cerrar el mismo. El botón para cancelarlo suele requerir de una especial destreza (o puntería) del usuario sobre su pantalla multitáctil… a menos que tengas los dedos del tamaño de la cabeza de un alfiler.

    Anuncio Intersticial, imagen de Google

    Pues bien, hace ahora más de 4 meses, Google anunció que iba a penalizar el uso de anuncios intersticiales en las búsquedas desde móvil a partir de enero de 2017, algo que ya está a la vuelta de la esquina.

    Es bueno recordarlo porque, a día de hoy, la mayor parte de las páginas de actualidad en Internet siguen incorporando este tipo de anuncios como si nada, haciendo muy incómoda la lectura, sobre todo en móviles, donde deshacerse del anuncio resulta complicado y por lo que, muchas veces, un servidor decide abandonar el medio de comunicación elegido para irme a uno alternativo que me informe más y me moleste menos.

    Aún me queda la esperanza de que esta penalización del buscador realmente consiga su efecto. Mientras tanto, seguiremos haciendo uso extensivo y abusivo de los bloqueadores de anuncios, pese a los avisos de determinados medios de que eso les hace daño.

    Lunes 05 de diciembre de 2016

    Emiliano A. González Salgado

    Emiliano A. González Salgado
    El blog de Emi

    Error al inicio de Linux debido a CUPS

    Uso Fedora 25 KDE. Desde hace tiempo y, con varias versiones anteriores. se está produciendo el mismo fallo al inicio del sistema.

    Para ver los errores que se han producido en el inicio de sesión, en los sistemas que incorporan Systemd, hay que teclear el comando:

    [root@HOST-PC ~]# journalctl -b -p err

    Uno de los que estaba arrojando últimamente era:
    cupsd[1213]: Missing value on line 11 of /var/cache/cups/job.cache.

    Los números 1213 y 11 pueden variar. El primero debe ser un índice de Journal (el registro de logs de Systemd) y el segundo hace referencia a la línea del fichero job.cache que produce el fallo.

    Es este caso era debido a que cups-pdf (la impresora virtual) al crear un fichero no le asignó un nombre en el archivo job.cache.

    Intenté borrar la caché de Cups desde el administrador de impresión (system-config-printer), pero no se encontraban trabajos pendientes ni terminados. También desde la interfaz web del servidor cups: http://localhost:631/jobs?which_jobs=all

    No era posible. No se podía borrar. Incluso eliminé el contenido de  job.cachecon un editor de texto, pero al volver a iniciarse el contenido estaba otra presente, así como el error se reproducía.

    Al final la solución llegó a través de la consola.

    Los comandos a ejecutar son:

    Parar Cups:

    [root@HOST-PC ~]# systemctl stop cups.service

    Ver la lista de trabajos completados:

    [root@HOST-PC ~]# lpstat -W completed -o

    Ver la lista de trabajos no completados:

    [root@HOST-PC ~]# lpstat -o

    Eliminar todos los trabajos:

    [root@HOST-PC ~]# cancel -a -x

    Esto cancelará todos los trabajos.

    Editar el fichero  /var/cache/cups/job.cache, borrar el contenido y guardar de nuevo.

    por ejemplo con nano como root

    [root@HOST-PC ~]# nano /var/cache/cups/job.cache

    Reiniciar el sistema y ver si se ha solucionado el fallo.

    SI las respuestas dadas aquí no funcionan:

    ps aux | grep printer kill {printer job}

    Este último comando no lo he probado. con lo anterior fue suficiente.

    Un saludo,

    Emiliano