Los paquetes y sus gestores

Si bien un mismo programa puede estar disponible para miles de distribuciones, el paquete con el cual se instala en cada una de ellas puede ser distinto. Cuando hablamos de paquete nos referimos al formato o extensión del archivo, el cual es usado por el sistema operativo para instalar un programa. Para que la distribución pueda usar ese archivo debe tener también un gestor de paquetes, el cual posee las herramientas para instalar, modificar o eliminar dicho programa. Esto es importante, porque si bien los programas no cambian entre una y otra distribución (es decir, Mozilla Firefox seguirá siendo Firefox en todas las distribuciones) es muy probable que si cambie el paquete usado para instalarlo.

Algunos formatos de paquetes son:

• deb: usado por Debian y sus derivados.
• RPM: (Red Hat Package Manager) originario de Red Hat y usado extensivamente por muchas otras como Fedora, OpenSUSE, Mandriva, Mageia y otros.
• PISI: de Pardus.
• MO: de Slax.
• PUP y PET: Puppy Linux.
• tar.gz: originario de Slackware, usado por muchas distribuciones y generalmente como formato de compresión.

Y algunos de los gestores de paquetes más conocidos:

• APT (terminal) y Synaptic (gráfico): usado por Ubuntu y sus derivados.
• Zypper (terminal) y YaST (gráfico): el gestor de OpenSUSE.
• YUM: Fedora y Yellow Dog Linux.
• Pacman: Arch Linux.
• dpkg: creado originalmente por Debian.
• Urpmi: Mandriva y Mageia.
• up2date: Red Hat.
• slapt-get, slackpkg y swaret: diversas “herramientas” que usa Slackware para trabajar con paquetes tgz.

¿Es importante que cambie un gestor de paquete entre distribuciones? Si. El hecho de que se decida por un gestor en detrimento de los demás implica que se busca una gestión eficiente de los paquetes a instalar. En definitiva, el gestor de paquetes define gran parte de la “esencia” de una distribución, y es un gran punto a tener en cuenta para diferenciarla de las demás. No voy a analizar cuál es mejor, aunque en internet existen varios ejemplos de lo que llamo “la guerra aptitude – zypper – yum”, en el cual los fanáticos de SUSE proclaman que Zypper sigue siendo el mejor.

Para ampliar: http://distrowatch.com/dwres.php?resource=package-management

La usabilidad

Otro tópico que se repite muy de seguido es el nivel de experiencia que precisamos tener para usar una distribución. Sucede muchas veces al aconsejar distribuciones a los novatos, o como nos habrá sucedido con nuestra primera distribución, que se suele escuchar “ni sueñes en probar Gentoo de entrada” o “Ubuntu es una buena opción para empezar”.

La dificultad de uso de una distribución se estima en cuanto a:

• la cantidad de elementos gráficos que ofrece.
• la cantidad de trabajo que obligatoriamente debe hacerse por consola (donde no existan alternativas gráficas para esa tarea).
• la dificultad de la instalación.
• el volumen de configuración que debe hacerse luego de la instalación de la distribución.
• si durante la instalación es necesario configurar la partición de discos o esta puede hacerse automáticamente.

Es por ello que es común agrupar ciertas distribuciones como las de nivel experto (Gentoo, Linux From Scratch, Slackware, Arch), las cuales no son recomendables para el usuario “intermedio-novato”. Últimamente se da un fenómeno que provoca que la tendencia de las distribuciones Linux se vuelque en brindar un Sistema Operativo cada vez más agradable para cualquier usuario. Aún así, siguen siendo destacables algunas distribuciones para los principiantes (Linux Mint, Ubuntu, Elementary OS, entre otros).

El hardware

No es una de las primeras cosas que se menciona al hablar de una distribución, pero no deja de ser algo importante. En un mundo que trata de desligarse del “sistema que cada vez pide más recursos” (Windows) y aún así mantenerse al día con los nuevos hardwares, existe un nicho de distribuciones que permite reciclar el hardware (Puppy Linux, Slitaz, Tiny Core Linux, AUSTRUMI, Slax, Lubuntu, Xubuntu, Alcolix, Damn Small Linux, Molinux, etc.). Si bien otras distros, como ser Linux Mint o Arch pueden instalarse en computadoras antiguas, llega un límite en la cual la fluidez del sistema se pierde, por ello existen distribuciones especializadas para ese tipo de hardware. Es más lógico, por ende, que algunas de estas distribuciones ofrezcan soporte a versiones de 32 bits y 16 bits; las más difundidas ofrecen soporte 32 y 64 bits.

Una distribución como Puppy Linux se destaca entonces en cuanto no es necesario estar al día con el hardware más potente del mercado actual, sino que es completamente funcional en computadoras con recursos simples, siempre y cuando no instalemos programas que requieran recursos excesivos.

Los formatos de lanzamiento

Es simple: una distribución suele venir en una serie de formatos que terminan por definir la esencia de la misma. Si bien los Live CD/DVD suelen ser comunes entre las distros populares, existen muchas otras que no usan dicho formato, absteniéndose a lanzar solamente versiones instalables.

La posibilidad de contar con un CD, DVD, Live CD/DVD, distintos entornos de escritorio por defecto o capacidad para instalar desde internet, es algo que influye en la decisión de muchos usuarios para probar una distribución o usarla definitivamente. También vemos que existen pre-lanzamientos que permiten a la comunidad testear la distribución antes de estar finalizada.

Otros puntos importantes también incluyen aquellas versiones para dispositivos portátiles y otras que distribuyen “Spin-Offs”, donde el ejemplo más concreto es el de Fedora, que cuenta con versión para Juegos, de Laboratorio y de Diseño, si bien esto, a mi parecer, es cuestión de instalar paquetes existentes en distintos repositorios. Por último, no olvido las distribuciones “rolling-release”, cuyos exponentes más claros son Debian, Arch y OpenSUSE, permitiendo actualizar el software y las versiones del sistema sin necesidad de realizar una nueva instalación o el miedo a perder datos personales.

El objetivo general

Cada distribución tiene en mente un objetivo con el cual pretende llegar a sus usuarios actuales o potenciales. De ahí podemos diferenciar a las que son específicas para portátiles (como JoliCloud que también está orientada al uso en la nube) y las de servidores (Red Hat Linux Enterprise es una de las más robustas y con mejor soporte actualmente).

Otras distribuciones tienen como objetivo el cuidado estético del escritorio y la similitud con otros sistemas (facilitando así la transición con estos), como es el caso de PearOS (con una estética similar a Mac), ZorinOS (que adapta GNOME para ofrecer un entorno similar a distintas versiones de Windows) y ElementaryOS (con un juego de íconos integrados y una instalación funcional por defecto); estas pueden presumir de diferenciarse de los entornos clásicos, pero estos aún pueden ser instalados en dichas distribuciones.

Aquellas distribuciones orientadas a un “público específico”, como Scientific Linux, Musix, Otakuxy otras, solo agregan aplicaciones específicas, lo cual en lo personal me parece insuficiente para destacarla del resto del grupo, dado que una aplicación puede ser instalada en cualquier sistema si se cuenta con el código fuente.

Para destacar también, existen algunas “rarezas”, como vemos en Globo Linux, una distribución modular que organiza los programas instalados de una forma distinta al resto de las distribuciones, de forma que los archivos de un mismo programa se encuentren juntos. Los directorios clásicos existen en efecto, pero están ocultos, de modo que en el directorio raíz por defecto vemos los siguientes directorios: Programs, Users, System, Files, Mount, Depot.

Otro buen ejemplo es Igelle, construida desde 0 para dar soporte a la mayor cantidad de dispositivos existentes. La distribución cuenta con un entorno de escritorio llamado Esther escrito en GTK+ y con Webkit como motor de renderizado.

Como cierre de esta nota, me gustaría destacar un elemento que a mi parecer también es algo trascendente que diferencia a las distribuciones: la comunidad que rodea a cada distribución es vital para el funcionamiento de esta. No son pocos los ejemplos donde las decisiones comunitarias o la falta de estas fijaron el rumbo (para éxito o fracaso) del desarrollo de una distribución, y es en donde los desarrolladores deben tener más cuidado y atención. También existieron casos donde un usuario abandona una distro por no tener problemas o dudas donde la comunidad no supo responder o brindar ayuda; es por ello que la imagen comunitaria, si bien es inherente al sistema operativo como tal, sigue jugando un papel central en destacar a una distribución por encima de otras.

Por último, no olviden leer la sección “Distribuciones” de este blog, que contiene información muy útil para los recién iniciados.

via: usemoslinux

Saludos, este post lo hago ya que no existe una información clara de como devolverse a la ROM original de Movilnet.

Yo actualice mi teléfono a la versión 2.2 con el gran manual que hizo Carlos Guerrero Android 2.2 y con el de Zizou que si esta arriba Zizou Android, resulta que tengo problemas con la Wifi Mac de este teléfono y no haya como resolverlo, entonces me da por ir a atrás a devolverla a la versión original a ver si puedo corregir el problema. se pasa de la siguiente manera, antes de eso hago una aclaratoria importante sobre lo que van hacer
A pesar de que estos proyectos te ayudan a sacar mayor provecho a tu Android, NO ME HAGO RESPONSABLE por equipos bloqueados, tarjetas SD muertas, ni por la guerra termonuclear ni por la crisis económica actual. Por favor investiga acerca de las características incluidas en estas ROM antes de flashearlas. USTED esta eligiendo hacer estas modificaciones y si me señalas a mi por dañar tu equipo, me reiré.

Paso para Realizar el cambio

1- Luego de eso hacemos lo siguiente obtenemos la ROM original de Movilnet, Descargar Rom Movilnet, luego que descargamos la ROM.

2- Conectamos nuestro celular a la computadora y descomprimamos el archivo dentro de la SD, si usan linux lo harían así.
Movemos el archivo a nuestra raíz de la SD y luego descomprimimos
unzip ROM_U8220_V100R001C32B820_Venezuela_Movilnet.zip
Luego de eso, nos generara una carpeta llamada U8220 V100R001C32B820b(Venezuela Movilnet), dentro de esa carpeta encontramos una carpeta dload, la cual la colocamos en la raíz principal, este sera el archivo que no hará devolver a la ROM original de Movilnet.

3- Desconectamos el celular de la conexión USB a nuestro computador y Luego que apagamos el celular.

4- Ejecutamos el modo BootLoader, lo arrancamos de la siguiente manera, mantenemos apretado el botón de subir volumen + tecla roja(finalizar llamada) + botón de encendido(Encendido).

5-Empezaran a ver que arranca y dice Unpacking, el cual inicia 2 fases para devolver a la versión anterior de Android, es recomendable tener buena carga de batería para ese procedimiento, luego que el completa los pasos 2/2, sacamos la batería del celular, cuando salga la palabra restarting.

6-Para que se coloque en practica lo que hicimos anteriormente, ejecutamos de la siguiente manera el encendido de nuestro teléfono, mantenemos apretado el botón de subir volumen + tecla roja(finalizar llamada) + botón de encendido(Encendido), es decir repetimos el paso 4. en ese mismo momento nos saldrán unas palabras Preparing to Update…

7- Luego encendemos nuestra teléfono de la manera normal y corriente, y volveremos a tener nuestro teléfono con Android 2.1 versión de original de Movilnet. Empezamos a configurarlo nuevamente.

Espero que sea útil para los que tenían dudas de como volver a una versión anterior

Otro correo que quiero convertir en entrada en mi bitácora. No importan los destinatarios para el fin del contenido.

...y si hay tecnologías privativas sin alternativas libres de las cuales
somos dependientes... bueno... buen momento para hacer lo que se
profesa, entonces.

Saludos, Este post lo hago por las tantas veces que he realizado este caso.

Sirve para los siguientes casos:
- Instalación de M$ en un Equipo Dual Boot
- Instalación de Linux y como reconocer M$
- Que hayas borrado Grub2.
- Que el chupa-cabras se haya apoderado de tu maquina.

Hacemos lo siguiente lo primero que tenemos que tener a la mano, es el live-cd, lo recomendable siempre tenemos uno de Ubuntu, siempre sacan las patas del barro.
Paso:

1- Luego arrancamos nuestro live-cd en nuestro computadora y esperamos que cargue todo el Sistema Operativo.

2- Nos ubicamos en Aplicaciones – Accesorios – Terminal y ejecutamos lo siguiente
sudo su
verificamos que somos root
whoami

3- creamos una carpeta dentro de /media/sistema
mkdir /media/sistema/

4- Luego verificamos nuestras particiones de manera de saber los números y tipos.
fdisk -l
Por que hacemos esto, en los disco Sata de los disco viene dada por SD y en caso de los disco Ide viene denotado por HD

5-Al ubicar nuestra partición raíz del sistema, puede estar ubicada en sda acompañada de un numero en este caso de pruebas sda5. todos puede variar dependiendo de las particiones que tengas, pero siempre la primera que vemos de arriba hacia abajo es la raiz (/).

6-Procedemos a montar nuestra partición raiz en la carpeta que creamos anteriormente
mount /dev/sda5 /media/sistema

7-Luego aprovechamos de montar los demás dispositivos
mount --bind /dev /media/sistema/dev
mount --bind /dev/pts /media/sistema/dev/pts
mount --bind /proc /media/sistema/proc
mount --bind /sys /media/sistema/sys

8- Luego entramos a nuestro antiguo sistema operativo Linux, para corregir la instalación de grub
chroot /media/sistema

9- Luego adentro realizamos otra vez la instalación de grub
grub-install --recheck /dev/sda
Nos saldrá una pantalla de que se ha instalado correctamente.

10- Por ultimo salimos de chroot, ejecutando exit y empezamos a desmontar los dispositivos y particiones.
umount /media/sistema/sys
umount /media/sistema/proc
umount /media/sistema/dev/pts
umount /media/sistema/dev
umount /media/sistema

11.Por ultimo finalizamos la sesión del live-cd y luego verán su grub otra vez.

12- En caso de que tengan un sistema operativo que agregar, entramos con nuestro linux y luego nos hacemos root, luego de ahí ejecutamos y nos reconocerá los demás sistemas operativos
update-grub2

Para mayor información revisar este how too Recuperar_GRUB

Ya a estas alturas todos deberíamos conocer sobre Android, en mi opinión, su popularidad ha sido gracias a su licencia abierta pues permite tanto a empresas como a la comunidad realizar modificaciones al sistema operativo para: adaptarlo a ciertos sectores del mercado, diferenciarse de otras compañías inversoras en esta tecnología, realizar ciertas optimizaciones, tener mayor control del software y hardaware, por mencionar algunos.

Cuando compras un teléfono el sistema Android que incluye por defecto fue desarrollado por la compañía fabricante (Samsung, HTC, Motorola, entre otros). Éste sistema tuvo que pasar por una serie de pruebas o certificaciones realizadas por Google y la compañía mencionada para garantizar el buen funcionamiento y estabilidad con el fin de mantener una buena imagen de Android, por ello, muchas modificaciones o funcionalidades deseadas no se encuentran presentes porque pueden sacrificar el rendimiento y/o estabilidad, afectando la imagen de ambas compañías. También por la misma razón, las compañías no suele actualizar la versión de android de los teléfonos por el tiempo que lleva: desarrollar los cambios, probarlos, certificar el resultado por Google y el dinero que consume realizar todo este proceso.

Cyanogenmod es una firmware realizado por la comunidad y soportado en una gran cantidad de dispositivos, la ventaja de este firmware son: inclusión de características y mejoras no soportadas por el resto de firmwares, permite a tu teléfono la última versión de Android a pesar de que no existan planes o versiones oficiales (si la compañía fabricante dice que no va a actualizar tu teléfono a la última versión gracias a Cyanogen puedes), incrementa  el tiempo de duración de la batería gracias a la activación de control de la frecuencia del CPU, inclusión de buenas aplicaciones extra como el navegador de archivos y reproductor multimedia, soporte de temas, mas opciones de personalización y mas.

Mi experiencia con Cyanogenmod la he disfrutado en 3 teléfonos:

• Motorola Milestone: Cyanogen 6 y 7 no oficial porque Motorola no actualizó el telefono a las últimas versiones de android.
• Samsung Spica: Cyanogen 7 no oficial  porque era la única ROM con Android 2.3 que funcionaba para ese teléfono.
• Nexus S: Cyanogen oficial 7.0,7.1, 9, 9.1 y 10.

Si observan, son teléfonos distintos y dice algo de versiones oficiales, resulta que la comunidad de Cyanogenmod da soporte una gran lista de teléfonos, pero aquellos no incluidos allí, pueden tener un firmware adaptado por un tercero permitiendo disfrutar del firmware (El caso del Motorola Milestone y Samsung Spica). El problema de las versiones no oficiales de Cyanogenmod, es la poca estabilidad del sistema, bien sea por: problemas de migración, drivers cerrados e incompatibles con otra versión, limitaciones, etc.

En el caso de Nexus S, he podido disfrutar las versiones oficiales tanto de Google como de Cyanogenmod. La ventaja de usar las oficiales de Google es la estabilidad del sistema, Android 4 (Ice Cream Sandwish) la use como por 8 meses y tuve como 1 reinicio y mas nada, además las actualizaciones al realizarse por OTA, no tuve que perder datos ni instalar aplicaciones al actualizar pero tiene las limitaciones mejoradas anteriormente.

Ventajas

Al instalar Cyanogen estable, pude darme cuenta la diferencia, se siente como un teléfono nuevo. El rendimiento es ligeramente superior (la mayoría de los usuarios no se darán cuenta), agrega mas opciones de personalización como temas, mas métodos de desbloqueo, permite editar parámetros avanzados como: velocidad de procesador, modo de rendimiento (en demanda, rendimiento, entre otros), manejo de la memoria, notificaciones a través de la iluminación del teclado y una característica llamada Deep Idle, éste último duerme todos los servicios y baja el consumo del procesador al mínimo cuando se apaga la pantalla, incrementado enormemente el uso de la bateria (en mi caso un 70% aproximado de mas tiempo).  También si utilizan su dispositivo para escuchar música mientras estas en el carro o mientras hacen ejercicio,  podrán notar lo dificil de estar mirando cada vez que desean cambiar la canción, con este firmware pueden utilizar los controles de volumen para cambiar entre pistas. También su launcher tiene ligeras modificaciones, como controles en la barra de notificaciones para activar y/o desactivar servicios, notificaciones mejoradas: permite usar las de Jelly Bean en versiones anteriores y algunas cosas extras como responder un SMS desde esta pantalla.

Desventajas

Las desventajas son pocas, la principal es el hecho que para instalarla se debe tener conocimientos de: obtener root en tu teléfono, modificar el bootloader (en algunos casos), instalar recoverys personalizados, respaldos NAND y otros. Cosas que no conocer el usuario promedio de Android y en los casos donde lo haces mal borras todo el contenido del teléfono. Sin embargo, existen guías explicando paso a paso para evitar este tipo de situaciones. Respecto a la estabilidad depende principal de 2 motivos: si la ROM es oficial del proyecto Cyanogenmod y de si existen los drivers del dispositivos para esa versión de Android. Si las dos se cumplen, te aseguro que correrá sin problemas, tal vez un reinicio rara vez pero es muy usable, de lo contrario puedes tener reinicios constantes o algun dispositivo del teléfono que no funcione.

Conclusiones

Realmente les recomiendo instalar Cyanogenmod si existe para su teléfono, la experiencia es superior a la ROM oficial de Google (no he usado las de HTC o Samsung), si tienen conocimientos de Linux, pueden jugar con la sección de “Rendimiento” y modificar los valores para obtener mayor tiempo de duración de la pila, ademas las mejoras visuales y de accesibilidad son muy buenas.

Para conocer del proyecto, visiten su sitio oficial: http://www.cyanogenmod.org/

En lo conversado con David, me surgió la idea de crear un planeta relacionado con Android, de nombre seria PlanetaAndroid(aprovechar todo lo creado en planetalinux), la idea es que los interesados creen una categoría en su blog, ya que hacen publicaciones de hack, aplicaciones, recomendaciones y todo lo relacionado con esta plataforma, soy uno de los tantos que me gustaría leer post de blogueros sobre dichas recomendaciones.

Que necesitamos: Gente son su blogs para participar.

Nombre y Apellido:
Blog con Categoría Android:
País:
Correo Electrónico:
Twitter.

Muchos ya conviven en planetalinux y se nos hará fácil ubicarlos, pero no gustaría que mencionaran el querer participar en este nuevo proyecto.

Pueden hacer replicar a este Ticket en Github o el post, con los datos que se piden.

Gracias por su atención

A partir de Ice Cream Sandwich apareció una nueva opción en el menú de Ajustes de nuestro teléfono. El apartado, llamado “Opciones de desarrollo“, agrupa todas las opciones relacionadas con la depuración del dispositivo, las entradas al sistema y el control de las aplicaciones. Ahí, podremos activar o desactivar ciertos aspectos del teléfono para que determinadas aplicaciones funcionen a pleno rendimiento o para que puedan acceder a ciertas zonas del sistema. Intentaré desgranar una a una todas las opciones para que no sea difícil entender para qué sirve cada una.

Iniciar herramientas

En esta apartado entramos a las opciones del sistema. No es recomendable tocar nada si no conocemos lo que vamos a cambiar. Aquí tendremos la posibilidad de testear y cambiar ciertos parámetros que no son recomendables para novatos en la materia.

Contraseñas copias ordenador

Aquí podremos hacer una copia de seguridad completa de nuestro teléfono en el ordenador. Según entremos, nos pedirá una contraseña para ejecutar la copia. Esta opción es necesaria para ejecutar ciertos programas, como el que presentamos para el Galaxy Nexus no hace mucho y que no necesitaba de permisos root para hacer los backups.

Pantalla activa

Nos permitirá dejar la pantalla encendida, o mejor dicho, desactivar el apagado automático de la pantalla, cuando el teléfono esté en carga o esté ejerciendo procesos en primer plano.

Comprobación HDCP

Aquí podremos activar o desactivar el control de protección de contenido digital. Para más información sobre este tipo de control de archivos multimedia, visiten este enlace.

Proteger TarjetaSD

Si lo activamos, protegeremos la tarjeta SD frente a cualquier aplicación que desee leer o escribir contenido en ella. Para que las aplicaciones puedan entrar, deberemos concederles permiso. Es posible que algunas aplicaciones fallen al activar este modo.

Acceso Administrativo

En este apartado podremos decidir si concedemos (o no) acceso administrativo a las aplicaciones, al ADB o a ambos.

Depuración USB

Ésto permitirá que algunas aplicaciones accedan a todo el sistema, así como para acceder a ciertos aspectos del sistema en modo depuración. Para los no iniciados en la materia, se suele activar para que funcione el Titanium Backup y más aplicaciones de ese tipo.

ADB sobre TCP/IP

Activa la opción anterior y permite conectar el terminal al ADB usando las interfaces Wifi o 3g.

Notificar depuración USB

Nos mostrará una notificación en el área de notificaciones cada vez que la depuración USB este activada. Muy útil si queremos desactivarla por algún motivo.

Ubicaciones y SMS simulados

Nos permitirá, en algunos casos, conectar el dispositivo a un GPS externo (entre otros usos). En el caso de los mensajes, nos servirá para simular el envío y recepción de SMS. Éso no quiere decir “simular que enviamos o recibimos un sms, como ciertas apps de la Play Store”, sino que se usa para labores de depuración de aplicaciones.

Aplicación para depurar

Por si queremos establecer una aplicación para depurar.

Mostrar pulsaciones / Ubicación del puntero

En este apartado, podremos ver si nuestro terminal reconoce exactamente el punto donde ponemos el dedo en la pantalla. Las pulsaciones se mostrarán como un círculo azul y, en la parte superior de la pantalla, nos saldrán las coordenadas del puntero. Una opción muy útil para ver si nuestra pantalla reconoce bien nuestras pulsaciones y conocer las coordenadas en la pantalla de éstas.

Mostrar límites de diseño

Si la activamos, veremos todos los márgenes de los elementos de la pantalla.

Actualizaciones GPU

Actualizará las vistas de las ventanas creadas con GPU cada vez que las abramos o cambiemos la posición de la pantalla. Ésto nos ayudará, en algunos casos, a aliviar la carga del procesador.

Cambios de superficie

Cada vez que el sistema reinicie una parte de la pantalla, ésta se reiniciará. Si activamos la opción (¡CUIDADO!) veremos cómo el teléfono se llena de colores y cambian rápidamente debido a lo citado anteriormente.

Escalas varias

Simplemente la escala a la que queremos ver las distintas opciones que ahí se detallan. En ella podremos alterar las velocidades a las que se muestra una ventana emergente, por ejemplo. Si ponemos la escala de animación de ventana a 10x, notaremos que ésta se abre mucho más lento.

Inhabilitar superposiciones HW

Activa la GPU para que se encargue de la combinación de las distintas pantallas.

Forzar aceleración GPU

Mejora el rendimiento del sistema bastante al dar mayor trabajo a la GPU y liberar la CPU.

Modo estricto

Si una aplicación se queda colgada, o tarda mucho en desarrollar su labor, destellará en la pantalla principal y podremos cerrarla sin problema.

Mostrar uso de la CPU

Mostrará los valores del uso de la CPU que tenga el terminal en cada momento en un lateral de la pantalla.

Habilitar seguimientos

Destruir actividadesPodremos activar el seguimiento de ciertos procesos del sistema, como el View, el Activity Manager o el Sync Manager.
Esta opción permite al sistema destruir los procesos inactivos. Es decir, que matará las aplicaciones en cuanto dejemos de usarlas.
Limitar procesos en segundo plano

En este apartado podremos escoger la cantidad de procesos en segundo plano que queremos permitir al sistema ejecutar. La variación va desde cero hasta cuatro. Aunque existe la posibilidad de dejar un límite estándar, que es el que el sistema considera oportuno en cada momento.

Errores sin respuesta

Si lo activamos nos informará, con una notificación emergente, siempre que una aplicación se quede “colgada“. Es decir, que no responda.

Botón volver

Gracias a esta opción podremos cerrar las aplicaciones haciendo una pulsación larga en el botón volver. Las aplicaciones cerradas de este modo no quedan en segundo plano y se cerrarán por completo, por lo que no aparecerán en el menú de aplicaciones recientes.

Y ya está

Básicamente, éso es todo. Cabe recordar que la mayoría de estas opciones son para quiénes saben lo que están tocando. Por lo que, salvo excepciones puntuales (como comentaba con el Titanium Backup & cía), no es conveniente andar jugando con ellas.

Espero que este repaso haya servido de ayuda y despejado algunas dudas. Es bueno conocer lo que tiene uno entre manos, aunque no lo use salvo en contadas ocasiones.

Con la salida de VirtualBox 4.2.x aproveché de actualizar los repositorios de una de las máquinas del trabajo, la cual corre Ubuntu 12.04. Para hacer esto basta con colocar lo siguiente en el archivo /etc/apt/sources.list:

deb http://download.virtualbox.org/virtualbox/debian precise contrib

Después de este cambio debes refrescar el listado de paquetes y actualizar VirtualBox:

aptitude update
aptitude install virtualbox-4.2

Repositorios en Debian

Para Debian testing (wheezy) y stable  (Squeeze) se deben colocar las siguientes líneas:

deb http://download.virtualbox.org/virtualbox/debian wheezy contrib
deb http://download.virtualbox.org/virtualbox/debian squeeze contrib non-free

Configuración en apt-cacher

Si seguiste la receta de apt-cacher y VirtualBox de este mismo blog, te informo que basta con modificar el /etc/apt/sources.list en los clientes como se explica arriba, es decir, el servidor de apt-cacher no sufre cambios.

Referencia:Download VirtualBox for Linux Hosts

Este artículo asume que ya conoces el propósito y las funciones fundamentales de git y que estás preparado para entender tareas más complejas. Si lo deseas, puedes leer la Guía básica de desarrollo con git antes de continuar.

Comenzar a trabajar en un proyecto de programación es relativamente fácil: simplemente comienza por donde más te guste y será suficiente.

Ahora, comenzar a versionar código depende realmente de cómo empezaste a programar. Si estás empezando desde cero, puedes hacer lo siguiente:

mkdir miproyectocd miproyectogit initgit add .git commit-a

git init inicializa el repositorio, git add . añade todos los archivos en el directorio actual al registro y git commit -a crea la importación inicial de los archivos.

Si por el contrario vas a descargar un proyecto git público ([URL]), debes hacer lo siguiente:

git clone[URL]

Por ejemplo:

git clone https://git.gitorious.org/canaima-gnu-linux/canaima-desarrollador.git

Cualquiera que sea el caso, ahora el árbol del proyecto está oficialmente versionado con git. Hay que notar que no importa cuántos subdirectorios tenga el proyecto, todo el sistema de versionamiento está guardado en una carpeta .git en el directorio raíz del proyecto (a diferencia de subversion, por ejemplo).

¡Ahora es tiempo de que hagamos algunas modificaciones! Edita algunos archivos dentro del proyecto canaima-desarrollador que acabas de clonar.

Cuando hayas terminado, lo siguiente que debes hacer es agregarlos al control de versiones con git add .. Pero antes, podemos obtener información interesante:

git diff

git diff te mostrará en formato de parche (diff) las modificaciones que acabas de hacer. Incluso, pudieras ver las diferencias entre el estado actual y un [COMMIT] anterior:

git diff[COMMIT]

O las diferencias entre un rango de commits:

git diff[COMMIT-A][COMMIT-B]

También, puedes obtener una representación más concisa de los cambios:

git status

Esto te mostrará una lista de todos los archivos modificados, agregados, borrados o que no han sido agregados al sistema de versionamiento. Además mostrará la rama actual de trabajo.

Para los archivos sin versionar, debemos agregarlos así:

git add .

O eliminarlos (en el caso de que se trate de archivos no deseados de un proceso de compilación, por ejemplo). ADVERTENCIA, esto eliminará todos los archivos sin seguimiento para siempre:

git clean-fd

También puedes especificar todos los archivos que deseas ignorar para siempre. Estos archivos nunca serán añadidos al control de versiones. Lo que hay que hacer es crear un archivo llamado .gitignore en el directorio raíz del proyecto, que contenga una lista de los archivos, línea por línea, especificando rutas relativas al directorio raíz.

Si realizaste un cambio en un archivo y todavía no has hecho commit, puedes restaurarlo desde el estado del último commit disponible con el siguiente comando:

git checkout[RUTA]

Finalmente es hora de guardar nuestros cambios:

git commit-a-m"[MENSAJE DESCRIPTIVO]"

Hay tres consideraciones a tener en cuenta:

En primer lugar, se debe especificar -a si se quiere hacer commit de todos los cambios versionados. En caso contrario, se debe usar git commit [RUTA] para hacer commit archivo por archivo.

En segundo lugar, los commits de git son privados por defecto, es decir, no son enviados a un servidor central a menos que se le especifique.

Y en tercer lugar, se acostumbra a colocar un [MENSAJE DESCRIPTIVO] que resuma en pocas palabras la modificación que se realizó en el código, así otros desarrolladores podrán entender fácilmente sin necesidad de revisar línea por línea los cambios realizados.

Explorando el proyecto

Ahora que hemos hecho commit de algunas cosas, es posible que queramos ver un registro de lo hecho hasta ahora:

git loggit blame[RUTA]

git log es un comando muy potente. Muestra el registro completo de todos los commits hechos en el historial, además de información adicional como autor y fecha. git blame también es muy útil ya que identifica el autor de cada línea de cada archivo registrado por git.

Por otro lado, se puede ver el contenido de un archivo en estado en que estaba para un determinado [COMMIT] con git show:

git show[COMMIT]:[RUTA]git show[COMMIT]:[RUTA]git show-s[COMMIT]git show[COMMIT]

Ramas y Etiquetas

Las ramas y etiquetas en git son tratadas como marcas asociadas a commits dentro del historial de trabajo. Se puede crear una rama con los siguientes comandos:

git branch[NUEVA][COMMIT]git checkout[NUEVA]

El primer comando crea una nueva rama basada en la rama donde nos encontramos en el momento. El segundo comando cambia el árbol de archivos a la rama recién creada. Es posible pasar un argumento adicional en el primer comando para basar la rama en un commit específico. Ejecutar git branch sin argumentos mostrará la lista de ramas existentes.

Para mover el árbol de archivos hasta cierto commit anterior, hacemos así:

git checkout[COMMIT]

Las etiquetas en git son muy similares a las ramas, pero con algunas características adicionales. Una etiqueta puede tener una fecha, un autor y un mensaje tal como los commits. Pueden ser firmadas por una llave PGP, lo que es útil a la hora de garantizar que el código original no ha sido modificado por nadie más. Para hacerlo, solo basta con hacer lo siguiente:

git tag[ETIQUETA]

Para una lista de las etiquetas existentes y mostrar el mensaje de la etiqueta:

git tag-lgit show[ETIQUETA]

Fusionando ramas

Supongamos que hemos estado trabajando en una nueva versión de nuestro software en una rama llamada “desarrollo” y que ya ha alcanzado un nivel de estabilidad tal que hemos decidido hacer un lanzamiento. Para ello, fusionaremos la rama “desarrollo” con la rama “estable” de la siguiente forma:

git checkout establegit merge desarrollo

Si los cambios se hicieron sólo en la rama “desarrollo” desde la última fusión, simplemente se copia su contenido en la rama “estable” (llamado fast-forward merge). Si se hicieron cambios en ambas ramas, se combinan de forma inteligente (llamado three-way merge). Si la fusión three-way no tiene conflictos de combinación, se genera un commit con un mensaje descriptivo (la opción --no-commit desactiva este comportamiento). Si hay conflictos de combinación (cuando las líneas de uno o más archivos que se fusionarán tienen valores diferentes en el estado anterior), git merge notificará acerca de todos los archivos en conflicto.

Para resolver un conflicto, debemos abrir cada archivo en conflicto y buscar el siguiente patrón:

<<<<<<<
Los cambios realizados en mi rama
=======
Los cambios realizados en la rama que estoy fusionando>>>>>>>

Debemos editar el archivo manualmente para dejar las líneas que consideremos apropiadas. Después de resolver todos los conflictos, se debe hacer commit:

git commit-a

Trabajando con servidores remotos

Si hemos descargado el proyecto a través de git clone, git ha configurado automáticamente un repositorio remoto llamado origin. Si hemos creado el proyecto a partir de cero, tendremos que configurarlo.

Para mostrar los servidores remotos configurados actualmente, se puede ejecutar el comando git remote. En él se enumerarán los nombres cortos de cada servidor remoto configurado.

git remote-v

Para añadir un nuevo servidor remoto como un nombre corto al que se puede hacer referencia fácilmente, ejecuta:

git remote add [NOMBRE][URL]

Si se ha clonado el repositorio, todas las ramas y etiquetas han sido descargadas. Sin embargo, las ramas no aparecerán en la lista a menos que antes se comiencen a utilizar con git checkout [RAMA].

Ahora, ¿Cómo se descargan nuevos cambios desde un repositorio remoto? Se puede utilizar git fetch para descargar los cambios. Si lo que deseamos es descargar y combinar los cambios con nuestra rama, hacemos git pull [NOMBRE] [RAMA].

Para subir cambios a un repositorio remoto, se utiliza el comando git push [NOMBRE] [RAMA]. Este comando sólo funciona si se ha clonado a partir de un servidor al que se tiene acceso de escritura y si nadie ha enviado cambios nuevos desde el momento en que se clonó. Si dos personas clonan el repositorio al mismo tiempo, uno sube cambios y luego el otro sube otros, el envío del último será rechazado. Se debe descargar los cambios del otro antes de subir los propios para que pueda funcionar.

Crudgen fue mi proyecto de tesis de grado que culminé a medidados del 2009, el mismo consiste en un generador de páginas para realizar operaciones CRUD (Create, Report, Update y Delete) en una base de datos Postgres a través de phppgadmin, el mejor gestor web para administrar este tipo de base de datos. Para ese entonces modifiqué el código fuente de varias partes de la aplicación, dificultando su integración en el programa, al año siguiente (2010) decidí reescribirlo y modificar su uso siguiendo las sugerencias del equipo, sin embargo, por falta de tiempo lo abandoné. En agosto de 2011, se agregó soporte para complementos por parte de Leonardo Sápiras al participar en el Google Summer of Code, permitiendo escribir un plugin con esta funcionalidad sin modificar el código fuente del programa.En el último año, cuando tenía tiempo libre me puse a rescribir (por tercera vez) el programa y hasta hace poco logré finalizarlo.

El plugin permite a través de pocos pasos, generar páginas web para realizar operaciones sobre las tablas seleccionadas de una base de datos. El código generadoson funciones PHP para realizar las acciones, las cuales son llamadas desde una plantilla HTML, esta plantilla, puede ser programada fácilmente o fácil de adaptar desde un diseño un existente, permitiendo obtener resultados con diseños personalizados (a diferencia de las otras soluciones donde todos los resultados tienen la misma apariencia).

Respecto al código del lado del servidor, soporta las bibliotecas PGSQL o PDO_PGSL brindando posibilidad al usuario de elegir la que mas le convezca (debería usarse siemper PDO para mayor seguridad), posee seguridad respecto a ataques de inyección SQL, usa PHP5 de fácil lectura y con flexibilidad para adaptarla a los requisitos del programador. Centraliza funciones comunes entre las páginas y mucho mas.

Si les interesa, les invito a ver este vídeo en inglés (me di cuenta que necesito prácticar) donde explico todo el funcionamiento del programa, sino entienden el idioma, no importa, pueden ver todo el proceso y ver lo que genera el plugin.

Espero que lo utilicen, compartan esta información, reporten bugs, se unan al proyecto y aporten código al mismo.

Este artículo contiene información avanzada relacionada con el desarrollo bajo versionamiento git. Si deseas ampliar tus conocimientos antes de continuar, puedes leer los siguientes artículos:

• Guía de desarrollo básico con git.
• Guía de desarrollo avanzado con git.
• El oráculo git del desarrollador.

Los submódulos en git permiten insertar uno o más repositorios externos dentro de otro repositorio. Es decir, permiten manejar uno o varios subproyectos dentro de un gran proyecto versionado con git. Esta característica puede ser útil, por ejemplo, para referenciar archivos que estén en proyectos complementarios, pero administrados por diferentes grupos o personas.

Por ejemplo, supongamos que tres personas se ponen de acuerdo para desarrollar una aplicación. La aplicación tiene una interfaz gráfica, un esquema de documentación y un esquema de generación de imágenes, por lo que se reparten el trabajo en partes iguales. El que escoja la interfaz principal, podría insertar los repositorios de desarrollo de sus otros dos compañeros en la ruta del proyecto correspondiente para realizar una integración de código. De esta forma, los tres proyectos siguen siendo independientes y pueden ser integrados y desintegrados en cualquier momento.

Para esta práctica, necesitaremos instalar git, lo cual podemos hacer introduciendo el siguiente comando desde una Terminal de Root (Menú > Aplicaciones > Accesorios > Terminal de Root):

aptitudeinstallgit

Luego, clonaremos el repositorio de Aguilas (sistema de autenticación del Proyecto Canaima) y entraremos en la carpeta con los siguientes comandos:

git clone git://github.com/HuntingBears/aguilas.gitcd aguilas

Aguilas contiene dos submódulos: el wiki para github y el wiki para google code. Estas características nos permitirán ilustrar mas adelante algunas funcionalidades de los submódulos.

Agregar un submódulo

Agregar un submódulo dentro de un proyecto git es relativamente sencillo. Por ejemplo, supongamos que queremos añadir documentación adicional para Aguilas dentro de la carpeta documentation/extradocs, desde un repositorio git externo ubicado en git://github.com/HuntingBears/fudcon-presentation.git. Lo hacemos así:

git submodule add git://github.com/HuntingBears/fudcon-presentation.git documentation/extradocs

Podemos diferenciar tres partes principales en este comando:

git submodule add: Esto simplemente le dice a git que se está agregando un submódulo.

[REPOSITORIO]: Este es el repositorio externo que debe ser agregado como un submódulo. La sintaxis exacta de la dirección variará de acuerdo a la permisología que se posee sobre el repositorio. Siempre se debe verificar que se tienen permisos de lectura sobre el repositorio.

[CARPETA]: Esta es la carpeta donde se insertará el repositorio dentro del repositorio principal o “anfitrión”.

Si hacemos git status, se podrá evidenciar que la carpeta suministrada fué creada, y que también se ha creado un archivo .gitmodules. Este nuevo archivo contiene los datos relacionados con el nuevo submódulo y puede contener lo siguiente:

[submodule "documentation/extradocs"]
path = documentation/extradocs
url = git://github.com/HuntingBears/fudcon-presentation.git

Si nos fijamos dentro de la carpeta documentation/extradocs, veremos que está vacía. A fin de completar la operación, es necesario inicializar y actualizar los submódulos. Desde la carpeta raíz de Aguilas, introduciremos los siguientes comandos:

git submodule initgit submodule update

Al revisar la carpeta documentation/extradocs, encontraremos los archivos correspondientes al proyecto de documentación.

Actualización de submódulos

Para actualizar el contenido de un submódulo, es decir, hacer un git pull del subproyecto más no del proyecto que lo alberga, debemos inicializar y actualizar los submódulos así:

git submodule initgit submodule update

Luego accedemos a la carpeta que contiene el submódulo:

cd documentation/extradocs

Cambiamos a la rama del subproyecto donde se encuentra la información:

git checkout master

Y hacemos la actualización del contenido:

git pull

Quitar un submódulo

¿Qué pasa si tenemos que quitar un submódulo? Tal vez cometimos un error. También podría ser que el diseño del proyecto haya cambiado, y la ruta del submódulo ya no es la misma. Por desgracia, git no posee una forma automática para remover submódulos. Se debe hacer manualmente.

Siguiendo con el ejemplo, vamos a quitar el submódulo que agregamos en documentation/extradocs. Para ello debemos realizar los siguientes pasos:

• Eliminar la entrada del submódulo en el archivo .gitmodules. Lo abrimos con gedit, vim, o tu editor de texto favorito, y eliminamos las tres líneas pertenecientes al submódulo. Para este caso, removemos las siguientes líneas:

[submodule "documentation/extradocs"]
path = documentation/extradocs
url = git://github.com/HuntingBears/fudcon-presentation.git

• Eliminar la entrada del submódulo en el archivo .git/config: Lo abrimos con gedit, vim, o tu editor de texto favorito, y eliminamos las dos líneas pertenecientes al submódulo. Para este caso, removemos las siguientes líneas:

[submodule "documentation/extradocs"]
url = git://github.com/HuntingBears/fudcon-presentation.git

• Eliminar del versionamiento la carpeta creada para el submódulo:

rm-rf documentation/extradocsgit rm--cached documentation/extradocs

Eso es todo lo que se debe saber para trabajar con submódulos en git. Espero que sea de utilidad.

Instalé Debian testing en mi Sony VAIO SVE-111 por sugerencia/regaño de mi amigo Roberto De Oliveira (@robertocdoa) ya que me estaba quejando de lo lento que se portaba Ubuntu en mi máquina, aparte de que la apariencia de Ubuntu dejó de gustarme hace rato.

Si bien la instalación fue rápida, luego de concluir y reiniciar la máquina nuevamente, al arrancar solo se veían una imagen distorsionada como se puede apreciar en la foto superior. Inmediatamente supuse que era un problema con el driver de video. Como no podía acceder ni siquiera a la consola de texto con el driver genérico  tuve que recurrir al viejo truco de acceder a una consola de texto desde el boot loader, como se muestra a continuación:

Esto permite cargar Bash en vez del arranque normal del sistema con init. Una vez que pude acceder al sistema tuve que remontar la partición raíz como lectura y escritura haciendo:

# mount -o remount,rw /

Aproveché para ver que el modelo exacto de mi tarjeta gráfica usé lspci como se muestra a continuación:

# lspci 
00:00.0 Host bridge: Advanced Micro Devices [AMD] Family 14h Processor Root Complex00:01.0 VGA compatible controller: Advanced Micro Devices [AMD] nee ATI Device 9808
00:01.1 Audio device: Advanced Micro Devices [AMD] nee ATI Wrestler HDMI Audio [Radeon HD 6250/6310]
00:04.0 PCI bridge: Advanced Micro Devices [AMD] Family 14h Processor Root Port

...

Hice una búsqueda sobre el driver para Debian de mi tarjeta gráfica y sugerían que usara la versión no libre que se encuentra en los repositorios non-free y contrib, por lo que debía agregarlos en en el archivo /etc/apt/source.list:

deb http://ftp.us.debian.org/debian squeeze main contrib non-free

Una vez hecho el cambio, procedía a actualizar e instalar el driver propietario de mi tarjeta gráfica:

# aptitude update

# aptitude install fglrx-control fglrx-driver

Instalar el driver no basta, se debe configurar también el archivo /etc/X11/xorg.conf para agregar las opciones de la tarjeta gráfica. Para este caso lo mejor es usar el utilitario que viene con el driver para generar este archivo. Para ello basta con ejecutar la siguiente orden:

# aticonfig --initial

Luego de esto pude usar el ambiente gráfico al reiniciar la PC, incluso con Gnome-Shell como puede verse ne la siguiente imagen:

Problemas con el TouchPad

Anteriormente había comentado cómo configurar el touchpad para esta máquina, pero esta configuración la hice en una máquina con Ubuntu. Con este driver la misma configuración en el archivo /etc/X11/xorg.conf no funciona, pero probando con la orden synclient me percaté que sí tomaba los parámetros, entonces simplemte convertí la configuración en el siguiente script:

#!/bin/sh

synclient LockedDrags=false
synclient VertEdgeScroll=1
synclient HorizEdgeScroll=false
synclient TapButton1=1 # Left click
synclient LTCornerButton=2 # Two-buttons click
synclient MaxDoubleTapTime=120
synclient TapButton2=3 # Right click
synclient EmulateTwoFingerMinZ=20
synclient EmulateTwoFingerMinW=5
synclient AreaBottomEdge=4500

Este script lo nombre synaptics.sh, y le habilité el permiso de ejecución:

 chmod +x synaptics.sh

Luego desde la opción Startup Programs de Gnome-Shell se configura para que se ejecute cuando inicie Gnome. Este programa de configuración se puede lanzar escribiendo en Gnome-Shell “Startup”, como se muestra a continuación:

Luego basta con agregar el script (hacer clic en el botón Add)  como se muestra en la siguiente imagen:

Después de esto tendrás la configuración como expliqué en mi otro artículo, donde se incluía “botones” especiales y un menú contextual al usar el clic con de dos dedos.

Referencias

• http://wiki.debian.org/AtiHowTo
• http://wiki.debian.org/ATIProprietary#Wheezy

Es un hecho que 1 de cada 255 mujeres y 1 de cada 12 hombres tienen algun tipo de deficiencia visual de color. Este reto de color online, está basado en el test oficial de X-Rite. Solo debes arrastrar cada cuadro de color para ordenarlos. El primer y ultimo cuadro de color son fijos. Una vez terminado, solo da click en “Score Test” (puntuar el test) y listo.

Cuentame como te fue en el test :D A mi me tocó tomarlo dos veces, ya que la primera vez mi puntuación fue patética ya que el sol se reflejaba en mi pantalla y no veía bien los colores, así que antes de realizarlo, busca una buena posición primero.

Un mantenedor de paquetes Debian es aquella persona que se encarga de transformar una determinada pieza de software (como por ejemplo una aplicación, un conjunto de scripts, archivos de imágenes, etc.) en otra pieza de software (un paquete) capaz de instalarse a través de un esquema común de instalación. El mantenedor Debian conoce muy bien el sistema operativo, y por tanto, sabe cuáles son los cambios que debe aplicar para hacer que la pieza de software funcione correctamente y de acuerdo a las normas y estándares de la distribución.

Una de las normas de calidad de Debian establece que no se debe tocar directamente el código de la pieza de software proveniente del desarrollador original. Si se debe hacer una modificación, debe hacerse a través de un parche durante el proceso de construcción del paquete. Esto permite aislar los cambios, asegurando que:

1. El conjunto de cambios reflejados en el parche pueden ser enviados a los desarrolladores originales para corregir errores o mejorar procesos.
2. Los cambios pueden ser aplicados a las sucesivas versiones del software, siempre y cuando las líneas afectadas no hayan sido modificadas por los desarrolladores originales.

Para mayor información puedes consultar la Guía para la creación de parches.

En líneas generales, quilt es una herramienta que asiste a un mantenedor de paquetes Debian, ayudando en la gestión de cambios y diferencias con respecto a los desarrolladores originales del software que contiene el paquete en mantenimiento. Permite crear y modificar parches, así como también aplicarlos o desaplicarlos.

Cada paquete Debian que contiene parches posee un archivo series (debian/patches/series), el cual almacena el nombre de cada uno de los parches que deben ser aplicados en el momento de construcción del paquete. Si se desea deshabilitar un parche en específico sin borrarlo (para uso posterior), simplemente se borra su nombre del archivo series. Quilt interpreta este archivo como una pila de nombres que pueden ser agregados y/o removidos según su orden de entrada y/o salida.

Para instalarlo, debemos introducir el siguiente comando desde una Terminal de Root (Menú > Aplicaciones > Accesorios > Terminal de Root):

aptitudeinstall quilt

Antes de comenzar a usar quilt, debemos configurarlo para que utilice siempre la carpeta debian/patches que se encuentra dentro de cada paquete. Para hacer esto, desde una Terminal de Usuario (Menú > Aplicaciones > Accesorios > Terminal) ejecuta el siguiente comando:

echo"QUILT_PATCHES=debian/patches"> ~/.quiltrc

Operaciones manuales con quilt

Quilt trabaja dinámicamente dentro del código fuente del paquete. No es necesario hacer copias previas del código, ni mantener el código duplicado, ni mucho menos ejecutar comandos diff, svn o git. El proceso de creación de un parche con quilt es relativamente sencillo y puede ser resumido de la siguiente manera:

1. Notificar a quilt que se va a trabajar con un parche en específico.
2. Trabajar en el parche.
3. Pedirle a quilt que actualice el contenido del parche en cuestión.

Para empezar a trabajar en un parche ejecutamos el siguiente comando en una Terminal de Usuario desde el directorio raíz del proyecto:

quilt new [NOMBRE]

Una buena práctica es anteponer una numeración al [NOMBRE] del parche y colocar la extensión .patch. Este comando creará una nueva entrada en debian/patches y se convertirá en el último parche aplicado en la pila. Para comenzar las modificaciones que formarán parte del parche, ubicamos la ruta del primer archivo a editar y hacemos:

quilt edit [RUTA]

Este comando lanzará nuestro editor de texto predeterminado para que realicemos las modificaciones. Luego de guardar el archivo, es posible editar tantos archivos como de deban editar para completar el cambio deseado. El parche contendrá todas las modificaciones; sin embargo, se recomienda separar los parches por módulo o por funcionalidad agregada/modificada, para mantener un orden. Siempre es preferible modularizar a hacer un parche gigante.

Cuando se termine la edición de archivos, escribiremos los cambios al parche con el siguiente comando:

quilt refresh

Con este comando hemos terminado la creación del parche, sin embargo es bueno saber que el parche ha quedado aplicado.

Si hacemos quilt applied podremos ver cuáles son los parches que están aplicados al código fuente. Para desaplicar el último parche de la pila, hacemos quilt pop. Esto hará que el próximo parche se ponga en el tope de la pila. Para desaplicar todos los parches que se encuentran el la pila, hacemos quilt pop -a.

De forma similar, para aplicar parches uno a uno se hace quilt push, y para aplicar todos los parches en la pila, se hace quilt push -a.

Para modificar un parche, dicho parche debe estar en el tope de la pila y aplicado. La forma más fácil de hacer esto es desaplicar todos los parches e ir aplicando uno por uno hasta llegar al parche que se desea modificar. También se puede hace quilt push [NOMBRE], si se conoce el nombre exacto del parche. Una vez hecho esto, se hace quilt edit [RUTA] para realizar la (o las) modificación(es) necesaria(s) y finalmente, quilt refresh.

Integrando con paquetes

Antes de la aparición de quilt, era necesario gestionar, aplicar y desaplicar parches manualmente durante la construcción de un paquete. Varias rutinas eran necesarias para completar esta tarea completamente, y aunque la lógica era sencilla, muchas veces representaba un dolor de cabeza para quienes se iniciaban en el mantenimiento de paquetes.

Si eres (o piensas ser) mantenedor para Debian, Canaima o Ubuntu, y quieres utilizar quilt para gestionar tus parches, es necesario que realices los siguientes cambios en tus paquetes:

1. Coloca el formato de construcción para el paquete fuente en 3.0 (quilt).
2. Añade la dependencia de construcción (Build-Depends) a quilt en el archivo debian/control.
3. Construye los parches manualmente como se explicó en este artículo.
4. Recuerda desaplicar todos tus parches antes de construir el paquete.

Cualquier duda, haz la pregunta en los comentarios.

Open VSwitch es un sistema de switch virtual, diseñado especificamente para habilitar automatización y despliegue de interfaces de red de manera programática, además soporta su distribución alrededor de múltiples servidores físicos, lo que lo hace ideal para la construcción de esquemas de redes virtuales para nubes.
OpenVSwitch es el esquema por defecto de gestión de redes de plataformas de virtualización con Citrix XenServer, openNebula y openStack y puede ser usado en KVM, Xen y Proxmox VE.

Open VSwitch

¿Por qué usar open VSwitch?

OpenVSwitch permite más capacidades que los módulos regulares del kernel Linux, aún cuando el Datapath está dentro del propio Kernel GNU/Linux, openVSwitch permite crear un “Soft Switch” en el hipervisor contando con características como QoS, LACP, etc; además, es el modo de gestión de redes virtuales en soluciones como OpenNebula, OpenStack y XenCenter (XCP).

Instalando open VSwitch

Para instalar openVSwitch en Debian Wheezy, realizaremos los siguientes pasos:

* Instalamos las dependencias:

apt-get install build-essential module-assistant

* Y los headers de nuestro kernel:

apt-get install linux-headers-`uname -r`

* removemos temporalmente los bridge-utils

apt-get remove --purge bridge-utils

* E instalamos el módulo para compilarlo en nuestro kernel:

apt-get install openvswitch-datapath-source

* Generamos el módulo para nuestro kernel:

module-assistant auto-install openvswitch-datapath

* Instalamos luego la compatibilidad con bridges linux

apt-get install openvswitch-brcompat openvswitch-common

* Completamos la instalación de openvswitch:

apt-get install openvswitch-switch

* Verificamos, que luego de instalado e iniciado, nos muestre la versión:

ovs-vsctl show
1dad3b56-0a78-4513-8480-be086ef042f7
ovs_version: "1.4.2"

Y Reiniciamos:

/etc/init.d/openvswitch-switch restart
[ ok ] ovs-brcompatd is not running.
[ ok ] Killing ovs-vswitchd (7353).
[ ok ] Killing ovsdb-server (7302).
[ ok ] Starting ovsdb-server.
[ ok ] Configuring Open vSwitch system IDs.
[ ok ] Starting ovs-vswitchd.

Con lo que ya tendremos openvswitch instalado en nuestro equipo.

Creando un bridge en Debian

Para crear un bridge contamos con tres formas, de la manera tradicional (en el archivo /etc/network/interfaces), con la herramienta tradicional bridge-utils o con los comandos propios de openvswitch.

Agregando una definición de bridge:

La definición de un bridge utilizando el archivo /etc/network/interfaces es igual a la forma tradicional, tomando en cuenta que todo bloque de definición debe empezar con la sentencia “allow-ovs” y el nombre de la interfaz, ejemplo:

Además, cada puerto asociado a un bridge (por ejemplo) deben ser incorporados a ovs, ejemplo:

Donde “allow-${bridge}” representa el nombre del bridge padre.

Ejemplos:

* Un bridge autónomo:

auto br0
allow-ovs br0
iface br0 inet static
   address 172.16.20.1
   netmask 255.255.255.0
 # bridge info
   ovs_type OVSBridge
   ovs_ports eth0
   bridge-ports eth0
   bridge-maxwait 1

Fijese en la opción ovs_type, puede ser OVSBridge, OVSPort, OVSIntPort u OVSBond de acuerdo a lo que  deseamos construir, también fijese que podemos mezclar con opciones compatibles con kernel bridge sin problemas.

Luego de definido un bridge, podemos definir un puerto (interfaz añadida al bridge):

# eth0
allow-hotplug eth0
allow-br0 eth0
iface eth0 inet manual
   ovs_bridge br0
   ovs_type OVSPort

Al reiniciar las interfaces, podemos ver su incorporación a OVS:

ovs-vsctl show
1dad3b56-0a78-4513-8480-be086ef042f7
 Bridge "br0"
       Port "eth0"
               Interface "eth0"
       Port "br0"
               Interface "br0"
        type: internal
 ovs_version: "1.4.2"

Agregando una definición de bond

Construir un bond es semejante en forma a la construcción de un bridge, tomando en cuenta que debemos encender las interfaces esclavas y configurar la pertenencia del bond a un bridge.

Definimos el bond:

auto bond0
allow-br0 bond0
iface bond0 inet manual
   ovs_bridge br0
   ovs_type OVSBond
   ovs_bonds eth0 eth1
   ovs_options bond_mode=balance-tcp lacp=active
   bond-miimon 100

Definimos las esclavas del bond (para que estén activas cuando este se cree):

auto eth0
iface eth0 inet manual
  bond-master bond0
auto eth1
iface eth1 inet manual
  bond-master bond0

Y por último, el bridge que gestionará el bond:

auto br0
allow-ovs br0
iface br0 inet static
   address 172.16.20.1
   netmask 255.255.255.0
   ovs_type OVSBridge
   ovs_ports bond0

Usando los comandos OVS para construir un bridge

Podemos crear un bridge fácilmente utilizando el comando “ovs-vsctl” siguiendo los siguientes pasos:

ovs−vsctl add−br br0
ovs−vsctl add−port br0 eth0

Aunque, podemos hacer ambas operaciones en una sola línea:

ovs−vsctl add−br br0 −− add−port br0 eth0

Nota: El double dash (–) es un separador entre opciones y comandos.

Podemos ver la interfaz con el comando “ovs-vsctl show” o utilizar el comando tradicional “brctl show”

brctl show
bridge name                bridge id                       STP enabled                           interfaces
br0                               8000.f0def1919e43             no                                     eth0

Definiendo una VLAN en un bridge

Para crear un bridge asociado a una VLAN, agregamos una interfaz interna etiquetada con el número de la VLAN:

* Creamos el bridge:

ovs-vsctl add-br br0

* Incorporamos una interfaz interna, etiquetada con el número de la VLAN (ejemplo, VLAN10):

ovs-vsctl add-port br0 vlan10 tag=10 -- set interface vlan10 type=internal

* Configuramos la interfaz:

ifconfig vlan10 192.168.10.254 netmask 255.255.255.0

Y listo!.

QoS sobre una interfaz en openVSwitch

También podríamos crear una regla de QoS sobre el ancho de banda de las interfaces participantes en un bridge, por ejemplo; podríamos definir una regla para limitar el ancho de banda de la interfaz eth0 a 10Mbps:

* Limitamos la interfaz eth0 a un máximo de Kbps que puede enviar (10000=10Mbps).

ovs-vsctl set interface eth0 ingress_policing_rate=10000
ovs-vsctl set interface eth0 ingress_policing_burst=1000

* Podemos también hacerlo a través la opción qos de un puerto;

ovs-vsctl -- set port eth0 qos=@newqos -- --id=@newqos create qos type=linux-htb other-config:max-rate=5000000 queues=0=@q0 
-- --id=@q0 create queue other-config:max-rate=5000000

Conclusiones

Espero les haya servido esta guía como a mí, yo no soy muy dado al área de redes, pero desde que estoy experimentando con virtualización (Xen, XCP-XAPI, KVM) pues he aprendido mucho acerca del control y gestión automatizado de interfaces; espero les sea de provecho.

Happy Hacking!

Debido a que el lector de pantalla Yars esta algo olvidado, aquí les explico como poder instalar Espeakup para poder usarlo con el terminal en modo texto, tengo que acotar que gracias a MK que es un usuario de la lista de tiflo-linux es que estoy redactando este post.

Ahora bien, yo lo instale en Debian squeeze y Canaima 3.1, también funciona en Ubuntu 12.04, dando muy buenos resultados, ya que se tiene acceso a toda la información que se desee, veamos como instalar y configurar este lector.

1. Instalamos Espeakup, abriendo un terminal (Aplicaciones (control+F1) > Accesorio > Terminal) y escribiendo como root:

#> aptitude install espeakup espeakup-tools -y

2. Como root editamos el archivo /etc/modules:

#> gedit /etc/modules

y escribimos al final del archivo:

speakup_soft start=1

guardamos (control+S) y cerramos (control+q)

3. Para que nos hable en español, editamos el archivo /etc/default/espeakup, así que como root en un terminal hacemos:

#> gedit /etc/default/espeakup

y en el parámetro voice escribimos:

VOICE=es

guardamos (control+S) y cerramos (control+q)

4. listo! solo nos toca reiniciar el equipo y tendremos a espeakup funcionando en el terminal de modo texto (control+alternar+F1).

En el siguiente enlace pueden conseguir información sobre Espeakup y los atajos para utilizarlo.

http://a11d.net/wiki/Manual_de_Speakup 

Es bueno recordar que si estamos en el terminal de texto (control+alternar+F1) y queremos regresar al entorno gráfico, debemos presionar las teclas alternar+F7.

Un saludo!

Ciertamente es segunda vez que escribo sobre el tema, pero ciertamente la gente sigue escribiendo y preguntando sobre el tema, es IMPOSIBLE que la gente de CANTV 0800-CANAIMA no sea capaz de orientar a la gente en este aspecto; pero bueno, trataré de hacerla más digerible que la primera versión de mi artículo.

Un amigo me envió esta foto de un fallo de las Canaimitas:

Este es un error de inconsistencia del disco (ocurren cuando has apagado demasiadas veces un equipo de manera incorrecta).

Cuando te encuentres en esta situación (“UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY”) es que debes chequear el disco de manera manual; para ello:

1.- escribes la contraseña de root donde dice “(Press CTRL-D to continue):” y presionas “INTRO”.

Nota: Hay blogs y referencias donde dan la clave de root de las Canaimitas (<< haga click acá si no la sabe), actualmente no recuerdo cual es.

Explicación: con esto entramos en el modo recuperación, mientras estén escribiendo la clave, no verán nada, tranquilos, escriban la clave y presionen tecla INTRO (ENTER).-

2.- escribes “umount /”

Explicación: esto desmonta la partición raiz, que vamos a chequear, también pueden escribir “umount /dev/sda1″

3.- ejecutas: “e2fsck -fy /dev/sda1″

Explicación: es ESTE el comando que chequea el disco, ejecutará el proceso de recuperación del disco, al finalizar dirá algo como “REBOOT LINUX”.

4.- montar la partición raíz “/”, escribes “mount -a”

Explicación: Al escribir “mount -a” verificamos que la partición monta correctamente, así podremos iniciar sin problemas.

6.- reinicias, escribiendo “reboot”

Y listo, disco reparado.

Nota: ¿por qué no entregan un manual con estos pasos de mantenimiento y otras tareas junto con la Canaimita?