joe di castro

Productividad en el escritorio Linux: Xmonad

joe di castro — Sat, 26 Nov 2011 00:00:00 +0100

xmonad es un Gestor de ventanas de mosaico, uno de los más empleados y de los más potentes. Después de haber probado varios (dwm, bluetile, wmii y el plugin Compiz Grid) llevo ya unos cuantos meses trabajando con él y posiblemente siga conmigo mucho, mucho tiempo. Una vez que trabajas con un tiling window manager es muy difícil que echarse atrás, volver a un gestor de ventanas flotantes tradicional es casi impensable. Probaré uno más, awesome, que promete mucho y solo si este logra convencerme del cambio, abandonaré Xmonad.

¿Pero que tiene de especial un twm como Xmonad para haber decidido abandonar la gestión de ventanas por defecto de Compiz, Gnome Shell, Unity, Kwin, etc y apostar por él? Cuando uno está cansado de perder el tiempo con maniobras y decisiones triviales -ajustar las ventanas en la pantalla, que si el navegador por aquí, que si este terminal por allá, etc y cambiando continuamente la mano del teclado al ratón y viceversa- pues entonces decides que hay que darle una oportunidad a un twm, que sea el gestor de ventanas quien haga el trabajo sucio por ti.

¿Y hasta que punto resuelve bien este problema un twm como Xmonad? En este vídeo de xmonad trabajando con mi configuración, uno se puede hacer una idea de lo que es capaz.

Esbozo de las posibilidades de un Tiling Window Manager como Xmonad trabajando conjuntamente con Gnome 3 y Unity 2D sobre un Ubuntu 11.10. Recomiendo ver en alta resolución y a pantalla completa.

Xmonad no necesita de un entorno de escritorio para trabajar, se puede iniciar una sesión directamente en él, al igual que la mayoría de gestores de ventanas de mosaico y otros gestores de ventanas como OpenBox. En el vídeo se puede apreciar que lo estoy empleando conjuntamente con Unity, en concreto Unity 2D. Esto es así porque emplear Xmonad (u otro twm) de forma autónoma te obliga a montar una serie de servicios que vienen montados por defecto normalmente en un escritorio, como salvapantallas, fondo de pantalla, bandeja de sistema, gestor de red, notificaciones, control de volumen, soporte impresoras, etc. Como estoy contento con el funcionamiento en general de Gnome, lo mejor es no reinventar la rueda y aprovechar lo mejor de los dos mundos empleando ambos a la vez. Anteriormente con Gnome 2, lo tenia funcionando sin Unity, pero con Gnome 3 me encuentro con la desagradable situación de que Gnome classic (el fallback mode) tiene un panel que es un autentico desastre y que además no es redimensionable en altura (tiene 30px y yo lo quiero con 21px). Actualmente hay una forma de arreglar esto, pero de momento lo tengo montado todo con Unity 2D y no hecho nada en falta. Eso si, de Unity solo empleo el panel, el Global Menu y la base de Gnome 3, lo demás lo descarto. Resumiendo, que básicamente sustituyo metacity por xmonad.

Xmonad con Unity 2D

Aquí contaré como tengo configurado actualmente Xmonad con Ubuntu 11.10 (Oneiric Ocelot) y con Gnome 3 y el panel de Unity 2D (unity-2p-panel). Si alguien continua con Gnome 2D o alguna versión anterior de Ubuntu puede revisar este enlace, la base es muy parecida, y luego solo habría que aplicar mi configuración (u otra).

Lo primero que se necesita es instalar xmonad, que en Ubuntu viene siendo así:

$ sudo apt-get install xmonad

A continuación crearíamos un fichero ~/.xmonad/xmonad.hs de configuración básica

$ mkdir ~/.xmonad           # El carácter ~ se obtiene pulsando Alt Gr + 4
$ vi ~/.xmonad/xmonad.hs    # Puedes emplear gedit en vez de vi si lo prefieres

e incluiríamos lo siguiente dentro de él:

import XMonad
import XMonad.Config.Gnome

myManageHook = composeAll (
    [ manageHook gnomeConfig
    , className =? "Unity-2d-panel" --> doIgnore
    , className =? "Unity-2d-launcher" --> doFloat
    ])

main = xmonad gnomeConfig { manageHook = myManageHook }

Ahora tendríamos que recompilar Xmonad, es algo necesario cada vez que realizamos algún cambio en la configuración, pero es un proceso que no suele llevar más de 5 segundos (y Xmonad se puede reiniciar sin tener que cerrar la sesión):

$ xmonad --recompile

Lo siguiente es crear los ficheros necesarios para crear una nueva sesión de Gnome. Creamos primero el fichero que define nuestra nueva sesión:

$ sudo vi /usr/share/gnome-session/sessions/xmonad.session

y dentro añadimos esto:

[GNOME Session]
Name=Xmonad Unity 2D
RequiredComponents=gnome-settings-daemon;
RequiredProviders=windowmanager;panel;
DefaultProvider-windowmanager=xmonad
DefaultProvider-panel=unity-2d-panel

a continuación creamos el fichero que inicia esta sesión:

$ sudo vi /usr/share/xsessions/xmonad-unity-session.desktop

con este contenido:

[Desktop Entry]
Name=XMonad Unity 2D
Comment=Tiling window manager
TryExec=/usr/bin/gnome-session
Exec=gnome-session --session=xmonad
Type=XSession

Con esto estaría ya montada una sesión con la configuración por defecto de Xmonad funcionado sobre Gnome y empleando el panel de Unity 2D. Ahora solo tendrías que cerrar la sesión e iniciar la sesión con Xmonad Unity 2D.

Advertencia: Por defecto verás que se ha creado automáticamente una sesión llamada Xmonad al instalar este. Bien, si vas iniciar esa sesión, será mejor que sepas que para salir tienes que pulsar Win + Mayús + Q, porque será una sesión donde solo tendrás Xmonad, y es la única forma de cerrar la sesión.

Si queréis hacer alguna prueba con esta configuración básica por defecto, es mejor tener a mano una referencia con las combinaciones de teclas disponibles, aquí hay un mapa del teclado de referencia que será muy útil.

Mi configuración

Para poder emplear la configuración que se puede ver en el vídeo simplemente habría que editar el fichero ~/.xmonad/xmonad.hs y sustituir su contenido por el de mi fichero de configuración. El contenido del fichero lo incluyo al final del articulo para no entorpecer la lectura del mismo.

Atajos de teclado

Al comienzo del fichero enumero las combinaciones de teclas empleadas en mi configuración, que difieren de las combinaciones por defecto y se asemejan de algún modo a las que estaba habituado en Gnome y son más intuitivas para los que estamos acostumbrados a él. Aunque las que se emplean por defecto también me son muy familiares al estar basadas en parte en Vim. Voy a detallar algunas de estas combinaciones.

Lanzar aplicaciones

-- Win  +  Enter                   Terminal
-- Win  +  F1                      Nautilus
-- Win  +  F2                      Firefox                  (single instance)
-- Win  +  F3                      Thunderbird              (single instance)
-- Win  +  F4                      RSSOwl                   (single instance)
-- Win  +  F5                      Hotot                    (single instance)
-- Win  +  F6                      ncmpcpp  - MPD player
-- Win  +  F7                      taskwarrior
-- Win  +  F8                      PAC                      (single instance)
-- Win  +  F9                      Aptana                   (single instance)
-- Win  +  F10                     Xmind                    (single instance)
-- Win  +  F11                     Dbeaver                  (single instance)
-- Win  +  F12                     VirtualBox               (single instance)

Lo primero que se puede ver es una serie de atajos para lanzar aplicaciones empleando la tecla Win más las teclas de función. La tecla Win (también llamada Super) es la tecla maestra por defecto de Xmonad (mod4Mask) y es la que se emplea en combinación con otras para realizar todo tipo de acciones. Estas combinaciones me permiten lanzar las aplicaciones que uso con más frecuencia con un par de teclas.

Algunas aparecen con la frase single instance entre paréntesis, esto quiere decir que de estas aplicaciones solamente se abrirá una ventana. De hecho, lo que ocurre si volvemos a pulsar la combinación de teclas que abre la aplicación (una vez que esta ya está abierta) es que en lugar de abrir una nueva, nos movemos a la ventana ya abierta, esté en el escritorio que esté. Lo que es muy útil para localizar la ventana de una de estas aplicaciones de forma inmediata.

Adicionalmente la combinación Alt + Enter nos permite abrir una ventana del terminal. En este caso lo tengo predeterminado para que abra una venta de terminator

Consola emergente

-- Win  +  Space                   Run or Raise Shell Prompt
-- Win  +  Shift   +  Space        Run Shell Prompt
-- Win  +  Control +  Space        Window Prompt

A continuación podemos ver las teclas dedicadas a la consola emergente inferior (al estilo de Guake, Yakuake o Tilda) y que según la combinación pulsada realizara una acción u otra. La consola cuenta con auto-completado de texto, con lo cual escribiendo las primeras letras se nos muestran todas las coincidencias disponibles, a través de las que podemos desplazarnos con el tabulador.

Win + Espacio nos despliega una consola que nos permite lanzar una aplicación de igual modo que los lanzadores gráficos. Si la aplicación ya se encuentra abierta, nos dirige a la ventana de la misma.
Win + Mayús + Espacio ejecuta el comando que escribamos. Similar a la ventana de ejecutar comando de Gnome (Alt + F2 en Gnome)
Win + Control + Espacio nos muestra las ventanas que están abiertas en ese momento. Seleccionando una nos envía directamente a ella. Gracias a esto, localizar una ventana abierta entre los múltiples escritorios es cuestión de segundos. Si conocemos el nombre de la ventana podemos filtrarla escribiendo las primeras letras con el teclado. Imagina una sesión en la que tenemos abiertas más de 10 aplicaciones en varios escritorios distintos, esto nos permite localizar una ventana en segundos, es muy útil.

Reiniciar Xmonad

Con la combinación Win + q lo que hacemos es reiniciar Xmonad sin necesidad de reiniciar la sesión. Esto es muy útil cuando introducimos cambios en la configuración, después de guardar el fichero y ejecutar xmonad --recompile en un terminal, pulsamos esta combinación y los cambios se reflejaran de forma inmediata.

Transparencias

Una de las carencias de Xmonad es que no incorpora un gestor de composición por lo que si queremos manejar transparencias en nuestros terminales, notificaciones, ventanas, etc, debemos emplear uno externo. Para esto empleo xcompmgr que funciona perfectamente y es muy ligero. Como aún conservo las otras sesiones de Ubuntu (Unity, Unity 2 D, Gnome Shell, etc) lo que hago para que solo se ejecute en la sesión de Xmonad Unity 2D es emplear este script bash:

#!/bin/bash

if [ $DESKTOP_SESSION = "xmonad-unity-session" ]; then
    xcompmgr -I1 -O1 -Ff;
fi

Luego añado el script a las aplicaciones que se ejecutan al inicio de la sesión y listo.

Bandeja del sistema

Una de las carencias de Unity en la versión 11.10 es que no han incorporado una bandeja del sistema donde alojar los iconos de aplicaciones que aún no tienen soporte para los indicadores. Se supone que debería añadirlos de forma automática al panel, incluso hay una configuración a través de dconf para habilitar esto, pero no funciona para todas las aplicaciones. Para añadir un systray empleo un script parecido al anterior para lanzar la aplicación trayer en esta sesión.

#!/bin/bash

MYARGS="--edge top --widthtype request --transparent true --alpha 0 --distancefrom right --distance 1100 --height 24 --tint 0x4c4a44 --align right"

if [ $DESKTOP_SESSION = "xmonad-unity-session" ]; then
    sleep 24 && trayer $MYARGS;
fi

Como personalizar Xmonad: Haskell

El mayor inconveniente de Xmonad (y a la vez una de sus ventajas) es que la configuración es necesario hacerla a través del mismo lenguaje de programación en el que está creado: Haskell. Esto es una importante barrera de entrada para los que no conocen el lenguaje, yo incluido, pero a base de ir probando algunas de las configuraciones aportadas y el prueba y error, puedes salir del paso muy satisfactoriamente. Con un poco de práctica y estudiando un poco el lenguaje (que de entrada no es de los más fáciles de leer) y gracias a la documentación disponible, puedes conseguir exactamente lo que quieres. Y esa es precisamente también su mayor ventaja, que puedes llegar a un gran nivel de personalización si conoces Haskell. Además Haskell le proporciona una gran estabilidad y extensibilidad.

Afortunadamente hay varios recursos disponibles que nos hacen el trabajo más fácil, porque Xmonad está aceptablemente bien documentado (en Inglés).

Xmonad.hs

Este es mi mi fichero de configuración de Xmonad:

-- joe di castro's xmonad.hs
-- Based on rupa's xmonad.hs, https://github.com/rupa/xmonad

-- ===============================================================  KEY BINDINGS

------------------------------------------------- Launch (or Raise) Applications
-- Win  +  Enter                   Terminal
-- Win  +  F1                      Nautilus
-- Win  +  F2                      Firefox                  (single instance)
-- Win  +  F3                      Thunderbird              (single instance)
-- Win  +  F4                      RSSOwl                   (single instance)
-- Win  +  F5                      Hotot                    (single instance)
-- Win  +  F6                      ncmpcpp  - MPD player
-- Win  +  F7                      taskwarrior
-- Win  +  F8                      PAC                      (single instance)
-- Win  +  F9                      Aptana                   (single instance)
-- Win  +  F10                     Xmind                    (single instance)
-- Win  +  F11                     Dbeaver                  (single instance)
-- Win  +  F12                     VirtualBox               (single instance)
----------------------------------------------------------- Shell/Window prompts
-- Win  +  Space                   Run or Raise Shell Prompt
-- Win  +  Shift   +  Space        Run Shell Prompt
-- Win  +  Control +  Space        Window Prompt
--------------------------------------------------------------------- Navigation
-- Win  +  [1..9]                  Switch to workspace N
-- Win  +  Shift   +  [1..9]       Move client to workspace N
-- Ctrl +  Alt     +  Left/Right   Previous/Next workspace
-- Alt  +  Tab                     Focus next window
-- Alt  +  Shift   +  Tab          Focus previous window
-------------------------------------------------------------- Window management
-- Win  +  Shift   +  Left         Move window to previous workspace
-- Win  +  Shift   +  Right        Move window to next workspace
-- Win  +  Control +  Left         Move window to previous empty workspace
-- Win  +  Control +  Right        Move window to next empty workspace
-- Ctrl +  Up/Down                 Move focused window up/down
-- Win  +  m                       Toggle focused window Full Screen
-- Win  +  n                       Refresh
-- Win  +  -                       Move focused windows to master area
-- Win  +  w  (or Alt + F4)        Close focused window
-- Win  +  t                       Back to tiling (unfloat floating window)
-- Win  +  Shift   +  t            Back All to tiling (unfloat ALL windows)
-------------------------------------------------------------  Layout management
-- Win  +  Tab                     Rotate layouts
-- Win  +  Left/Right              Shrink/Expand the master area
-- Win  +  Up/Down                 Mirror Shrink/expand
-- Win  +  ,/.                     Increment/Deincrement 1 window in master area
-- Win  +  f                       Hide/Unhide the gnome-panel/status bar
-- Win  +  Shift   +  n            Reset current workspace to main layout
------------------------------------------------------------------ Mosaic Layout
-- Win  +  a/z                     Taller/Wider
-- Win  +  Control +  n            Reset
------------------------------------------------------------------------- Others
-- Print Screen                    Capture screen
-- Win  +  q                       Restart XMonad
-- Win  +  Shift   +  q            Close gnome session dialog

-- ============================================================== MOUSE BINDINGS

-- Win  +  Button 1                Float Window and Move by dragging
-- Win  +  Button 2                Raise Window to the top
-- Win  +  Button 3                Float Window and Resize by dragging

import XMonad
import qualified XMonad.StackSet as W
import qualified Data.Map        as M
import Data.Monoid

import XMonad.Actions.CycleWS
import XMonad.Actions.FlexibleResize as Flex
import XMonad.Actions.SinkAll
import XMonad.Actions.UpdatePointer
import XMonad.Actions.WindowGo

import XMonad.Hooks.DynamicLog
import XMonad.Hooks.EwmhDesktops
import XMonad.Hooks.ManageDocks
import XMonad.Hooks.ManageHelpers

import XMonad.Layout.LayoutHints
import XMonad.Layout.NoBorders
import XMonad.Layout.ResizableTile
import XMonad.Layout.Tabbed
import XMonad.Layout.ToggleLayouts
import XMonad.Layout.WindowArranger
import XMonad.Layout.Mosaic

import XMonad.Prompt
import XMonad.Prompt.Input
import XMonad.Prompt.RunOrRaise
import XMonad.Prompt.Shell
import XMonad.Prompt.Window

import XMonad.Util.Run
import XMonad.Util.Scratchpad
import XMonad.Util.WorkspaceCompare
import XMonad.Util.XSelection

import XMonad.Config.Gnome

-- Mod4 is the Super / Windows key
winMask = mod4Mask
altMask = mod1Mask

-- key bindings
myKeys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
    [ ((winMask,                    xK_Return   ), spawn $ XMonad.terminal conf)
    , ((winMask,                    xK_F1       ), spawn "nautilus ~")
    , ((winMask,                    xK_F2       ), runOrRaise "firefox" (className =? "Firefox"))
    , ((winMask,                    xK_F3       ), runOrRaise "thunderbird" (className =? "Thunderbird"))
    , ((winMask,                    xK_F4       ), runOrRaise "./rssowl/RSSOwl" (className =? "RSSOwl"))
    , ((winMask,                    xK_F5       ), runOrRaise "hotot" (className =? "Hotot"))
    , ((winMask,                    xK_F6       ), spawn "terminator -e ncmpcpp")
    , ((winMask,                    xK_F7       ), spawn "terminator -e 'task shell' -p task")
    , ((winMask,                    xK_F8       ), runOrRaise "pac" (className =? "Pac"))
    , ((winMask,                    xK_F9       ), runOrRaise "./Aptana Studio 3/AptanaStudio3" (className =? "Aptana Studio 3"))
    , ((winMask,                    xK_F10      ), runOrRaise "/usr/local/xmind/xmind" (className =? "XMind"))
    , ((winMask,                    xK_F11      ), runOrRaise "./dbeaver/dbeaver" (className =? "DBeaver"))
    , ((winMask,                    xK_F12      ), runOrRaise "VirtualBox" (className =? "VirtualBox"))
    , ((winMask,                    xK_space    ), runOrRaisePrompt mySP)
    , ((winMask .|. shiftMask,      xK_space    ), shellPrompt mySP)
    , ((winMask .|. controlMask,    xK_space    ), windowPromptGoto mySP)
    , ((0,                          xK_Print    ), unsafeSpawn "gnome-screenshot")
    , ((altMask .|. controlMask,    xK_Right    ), moveTo Next (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((altMask .|. controlMask,    xK_Left     ), moveTo Prev (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. shiftMask,      xK_Right    ), shiftTo Next (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. shiftMask,      xK_Left     ), shiftTo Prev (WSIs (return $ not . (=="NSP") . W.tag)))
    , ((winMask .|. controlMask,    xK_Right    ), shiftTo Next EmptyWS)
    , ((winMask .|. controlMask,    xK_Left     ), shiftTo Prev EmptyWS)
    , ((winMask,                    xK_Tab      ), sendMessage NextLayout >> (dynamicLogString myPP >>= \d->safeSpawn "gnome-osd-client" [d]))
    , ((altMask,                    xK_Tab      ), windows W.focusDown)
    , ((altMask .|. shiftMask,      xK_Tab      ), windows W.focusUp)
    , ((controlMask,                xK_Down     ), windows W.swapDown)
    , ((controlMask,                xK_Up       ), windows W.swapUp)
    , ((winMask,                    xK_Left     ), sendMessage Shrink)
    , ((winMask,                    xK_Right    ), sendMessage Expand)
    , ((winMask,                    xK_Down     ), sendMessage MirrorShrink)
    , ((winMask,                    xK_Up       ), sendMessage MirrorExpand)
    , ((winMask,                    xK_minus    ), windows W.shiftMaster)
    , ((winMask,                    xK_comma    ), sendMessage (IncMasterN 1))
    , ((winMask,                    xK_period   ), sendMessage (IncMasterN (-1)))
    , ((winMask,                    xK_n        ), refresh)
    , ((winMask .|. shiftMask,      xK_n        ), setLayout $ XMonad.layoutHook conf)
    , ((winMask ,                   xK_a        ), sendMessage Taller)
    , ((winMask ,                   xK_z        ), sendMessage Wider)
    , ((winMask .|. controlMask,    xK_n        ), sendMessage Reset)
    , ((winMask,                    xK_m        ), sendMessage (Toggle "Full") >> (dynamicLogString myPP >>= \d->safeSpawn "gnome-osd-client" [d]))
    , ((winMask,                    xK_t        ), withFocused $ windows . W.sink)
    , ((winMask .|. shiftMask,      xK_t        ), sinkAll)
    , ((winMask,                    xK_f        ), sendMessage ToggleStruts)
    , ((winMask,                    xK_w        ), kill)
    , ((altMask,                    xK_F4       ), kill)
    , ((winMask,                    xK_q        ), broadcastMessage ReleaseResources >> restart "xmonad" True)
    , ((winMask .|. shiftMask,      xK_q        ), spawn "gnome-session-quit")
    ]

    ++
    -- mod-[1..9], Switch to workspace N
    -- mod-shift-[1..9], Move client to workspace N
    [ ((m .|. winMask, k), windows $ f i)
        | (i, k) <- zip (XMonad.workspaces conf) [xK_1 .. xK_9]
        , (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)] ]

-- mouse bindings
myMouseBindings (XConfig {XMonad.modMask = modMask}) = M.fromList $
    [ ((winMask, button1), (\w -> focus w >> mouseMoveWindow w))
    , ((winMask, button2), (\w -> focus w >> windows W.shiftMaster))
    , ((winMask, button3), (\w -> focus w >> Flex.mouseResizeWindow w)) ]

-- decoration theme
myDeco = defaultTheme
    { activeColor           = "orange"
    , inactiveColor         = "#222222"
    , urgentColor           = "yellow"
    , activeBorderColor     = "orange"
    , inactiveBorderColor   = "#222222"
    , urgentBorderColor     = "yellow"
    , activeTextColor       = "orange"
    , inactiveTextColor     = "#222222"
    , urgentTextColor       = "yellow"
    , decoHeight            = 10 }

-- tab theme
myTab = defaultTheme
    { activeColor           = "black"
    , inactiveColor         = "black"
    , urgentColor           = "yellow"
    , activeBorderColor     = "orange"
    , inactiveBorderColor   = "#222222"
    , urgentBorderColor     = "black"
    , activeTextColor       = "orange"
    , inactiveTextColor     = "#222222"
    , urgentTextColor       = "yellow" }

-- shell prompt theme
mySP = defaultXPConfig
    { bgColor               = "black"
    , fgColor               = "white"
    , bgHLight              = "gray"
    , fgHLight              = "black"
    , borderColor           = "orange"
    , promptBorderWidth     = 2
    , position              = Bottom
    , height                = 40
    --, autoComplete        = Just 1000
    , historySize           = 1000 }

-- dynamicLog theme (suppress everything but layout)
myPP = defaultPP
    { ppLayout  = (\ x -> case x of
      "Hinted ResizableTall"        -> "[|]"
      "Mirror Hinted ResizableTall" -> "[-]"
      "Hinted Tabbed Simplest"      -> "[T]"
      "Mosaic"                      -> "[M]"
      "Full"                 -> "[ ]"
      _                      -> x )
    , ppCurrent             = const ""
    , ppVisible             = const ""
    , ppHidden              = const ""
    , ppHiddenNoWindows     = const ""
    , ppUrgent              = const ""
    , ppTitle               = const ""
    , ppWsSep               = ""
    , ppSep                 = "" }

-- layouts
myLayout = avoidStruts $ toggleLayouts (noBorders Full)
    (smartBorders (tiled ||| mosaic 2 [3,2] ||| Mirror tiled ||| layoutHints (tabbed shrinkText myTab)))
    where
        tiled   = layoutHints $ ResizableTall nmaster delta ratio []
        nmaster = 1
        delta   = 2/100
        ratio   = 1/2

-- special windows
myManageHook = composeAll
    [ className =? "MPlayer"                --> doFloat
    , className =? "Gimp-2.6"               --> doFloat
    , className =? "Gnome-panel"            --> doIgnore
    , className =? "XVkbd"                  --> doIgnore
    , className =? "Cellwriter"             --> doIgnore
    , className =? "Gtkdialog"              --> doFloat
    , resource  =? "desktop_window"         --> doIgnore
    , className  =? "Xmessage"              --> doCenterFloat
    , className =? "Unity-2d-panel"         --> doIgnore
    , isFullscreen                          --> doFullFloat
    , isDialog                              --> doCenterFloat
    , title =? "RSSOwl"                     --> doIgnore
    , title =? "Dbeaver"                    --> doIgnore
    , title =? "Xmind-bin"                  --> doIgnore
    , title =? "AptanaStudio3"              --> doIgnore
    , resource =? "sun-awt-X11-XDialogPeer" --> doCenterFloat
    , title =? "screenkey"                  --> doIgnore
    , className =? "Gloobus-preview"        --> doCenterFloat
    --                                      x y w h
    , scratchpadManageHook $ W.RationalRect 0 0 1 0.42
    , manageDocks ] <+> manageHook defaultConfig

-- let Gnome know about Xmonad actions
myLogHook = ewmhDesktopsLogHookCustom scratchpadFilterOutWorkspace >> updatePointer (Relative 0.5 0.5)

myConfig = ewmh defaultConfig
    { terminal           = "terminator"
    , borderWidth        = 2
    , normalBorderColor  = "black"
    , focusedBorderColor = "orange"
    , focusFollowsMouse  = True
    , modMask            = mod4Mask
    , keys               = myKeys
    , mouseBindings      = myMouseBindings
    , layoutHook         = myLayout
    , manageHook         = myManageHook
    , startupHook        = gnomeRegister
    }

-- need to override ewmh's logHook cause I'm using Scratchpad
main = xmonad $ myConfig
    { logHook            = myLogHook }

Productividad en el escritorio Linux: Tiling

joe di castro — Fri, 25 Nov 2011 00:00:00 +0100

Los Gestores de Ventanas de Mosaico (Tiling Windows Manager) son el gran desconocido entre la mayoría de usuarios de Linux. Y sin embargo, a mi juicio, suponen el salto más importante en productividad en el escritorio linux que se haya producido en mucho tiempo. Permiten manejar todo el escritorio sin apenas despegar las manos del teclado y sin verse relegado a emplear únicamente la consola. Las ventanas se distribuyen ellas solas de forma automática por la pantalla y no es necesario emplear el ratón para moverlas y redimensionarlas (aunque puede seguir empleándose, naturalmente).

A diferencia de un gestor de ventanas tradicional, a los que estamos normalmente acostumbrados, las ventanas no se apilan y flotan unas encima de otras, si no que se redistribuyen por toda la pantalla de acorde a un esquema previo (variable) sin solaparse entre ellas, quedando todas a la vista de forma simultanea. De ahí el símil del mosaico, donde el mismo seria el escritorio y donde las ventanas serian las teselas que lo componen. Puede no ser fácil visualizar de entrada en que consiste exactamente esto y como funciona, luego los vídeos nos ayudarán a entender mejor de lo que estoy hablando. Aunque uno no aprecia realmente las ventajas que aportan hasta que prueba uno.

¿Que ventajas tienen?

Primero mencionar que esto no es una idea nueva, ni mucho menos, esto ya lo inventó en 1981 Xerox (el inventor a su vez de los entornos de ventanas) e incluso MS Windows 1.0 lo empleaba. La razón de que algo desarrollado desde hace dos décadas aún no haya llamado demasiado la atención hasta ahora, es bien sencilla, el triunfo de un dispositivo de entrada más amigable e intuitivo que el teclado: el ratón. La metáfora de el entorno de ventanas con el escritorio junto con la del ratón como la extensión de nuestro brazo, propiciaba que fuera lo más natural emplearlo para mover las ventanas y redimensionarlas. Pero que sea más fácil o intuitivo no quiere decir que sea más eficiente, nadie en su sano juicio escribiría un documento empleando el ratón sobre un teclado virtual ni realizaría retoque fotográfico empleando únicamente el teclado. ¿Pero cuantos dirían que el teclado es el medio más eficiente para manejar las ventanas?

En una pantalla de grandes dimensiones y elevada resolución (e.g. un monitor de 24" y 1920x1200) es muy frecuente andar redimensionando continuamente las ventanas para acomodarlas y redistribuirlas dentro del escritorio. Nos sobra espacio por todos los lados y la mayoría de las aplicaciones que en monitores y resoluciones menores empleábamos maximizadas, ahora son incomodas de usar a pantalla completa (e.g. navegador web). ¿No sería útil que las ventanas se recolocaran y redimensionaran automáticamente por si solas? Más o menos esto es lo que viene a hacer un gestor de ventanas de mosaico.

Pero cuales son las ventajas reales de este sistema:

Las ventanas se organizan solas, muchas veces no necesitas mover o redimensionar una ventana, simplemente aparece en un lugar adecuado y con las dimensiones adecuadas. Una vez le que coges el truco te organizas de manera que esto ocurre con cierta naturalidad.
Se aprovecha todo el espacio de la pantalla. Las ventanas se ajustan a todo el espacio libre disponible del escritorio. Aún así pueden emplearse paneles, docks, ...
Las ventanas normalmente apenas tienen marco y carecen de barra de titulo y decoraciones, por lo tanto se ahorra espacio. Combinado con un menú integrado como el Global Menu de Unity, se ahorra mucho espacio.
No es un método excluyente, aún se pueden emplear con toda normalidad las ventanas flotantes como habitualmente. Incluso pueden convivir entre ellas sin problema alguno.
En un sistema de múltiples monitores se facilita mucho el manejo de las múltiples ventanas y el tener simultáneamente abiertas un número elevado de ellas es algo realmente sencillo.
Es posible automatizar el tamaño, posición y escritorio virtual en donde se situara la ventana(s) de una aplicación al iniciarse, lo que abre un mundo de posibilidades.
Es posible tener múltiples escritorios virtuales (usualmente 9 por monitor) con características distintas en cada uno. Puede ser un esquema distinto (desde una simple rejilla a un escritorio normal) o un escritorio para cada tarea (e.g. 1 - navegar, 2 - correo y redes sociales, 3 - trabajo, 4 - terminales, ...)
Mover las ventanas, redimensionarlas, lanzar aplicaciones, cerrarlas, ... y manejar los escritorios virtuales desde el teclado es mucho más eficiente que emplear el ratón para lo mismo.
Te olvidas de buscar una ventana entre la pila de ventanas flotantes sobre el escritorio, es sencillo incluso encontrar una ventana dentro de otro escritorio virtual (con unos gestores más que otros). Los escritorios modernos permiten mostrar un mosaico con todas las aplicaciones abiertas (Exposé, Scale, ...), ¿pero que ocurre cuando tienes abiertas cerca de 30? con un twm la localizas enseguida si lo configuras adecuadamente, en mi caso menos de 2 segundos.
Te permite organizar las ventanas en función de múltiples patrones distintos: rejillas, columnas, filas, espirales, por pestañas, etc... de forma automática, acomodándose a múltiples situaciones distintas.
Se pueden emplear de forma autónoma, sin un escritorio detrás (gnome, kde, ...) lo que permite tener un sistema muy ligero ideal para equipos poco potentes.
Puede ser una manera de mejorar la accesibilidad del escritorio para aquellos que encuentren dificultades para manejar un ratón pero puedan defenderse con un teclado.

Inconvenientes

No son para todo el mundo. Soy plenamente consciente de ello, una buena mayoría de los usuarios son reticentes a aprenderse los atajos de teclado de una aplicación (hay quien no sabe cortar y pegar desde él), así que entiendo perfectamente que siquiera lleguen a plantearse el emplearlos. De hecho los tímidos avances que están realizando los escritorios en este sentido implican el uso del ratón para implantar un sucedáneo de este sistema. También es una cuestión de gustos, habrá a quien simplemente la desagradará el como funciona este sistema.

Por otro lado los profesionales multimedia que requieren un uso elevado del ratón probablemente prefieran seguir empleando un gestor de ventanas tradicional, aunque los gestores de mosaico pueden moverse con soltura en este entorno.

También es cierto que la mayoría de ellos requieren un esfuerzo por nuestra parte para configurarlos a nuestro gusto. Aunque es precisamente esto lo que nos permite configurarlos exactamente a nuestro gusto, con muchas posibilidades de configuración. Pero es una barrera de entrada importante para los gestores más potentes y completos. Alguno hasta requiere conocimientos en algún lenguaje de programación (C, Lua, Haskell)

Aunque por un lado pueden suponer una ventaja en la accesibilidad a determinados discapacitados, pueden suponer un escollo para otros, pues no están tan adaptados como puedan estarlo los escritorios tradicionales para determinadas discapacidades.

Tipos de gestores

Básicamente existen dos tipos de gestores de ventanas de mosaico, en función de el modo de organización de las ventanas.

Manuales, requieren que el usuario sea quien decida la posición (a veces el tamaño) de las ventanas, con el inconveniente de la perdida de tiempo a costa de lograr un control más preciso.
Automáticos, ajustan automáticamente la posición y el tamaño de las ventanas en función del esquema por defecto. Posteriormente podemos variar tanto el esquema como la posición y tamaño de las ventanas individuales.

Adaptación de la idea en los escritorios más comunes

Tal y como ocurre con los lanzadores de aplicaciones, los escritorios más tradiciones de linux comienzan a incorporar esta idea a sus desarrollos, en mayor o menor medida. Unity, Compiz, Gnome y KDE se han atrevido a dar un paso en esta dirección en sus últimas versiones:

Compiz Grid, es un plugin de Compiz que permite realizar un tiling primitivo, empleando el ratón o el teclado. Divide la pantalla en una rejilla de 3 x 3 y permite que las ventanas se ajusten al tamaño de una cuadricula o varias. Manejarlo desde el teclado es muy sencillo, simplemente pulsamos Ctrl + Alt + una tecla del teclado numérico del 1 al 9 según la cuadricula a la que la queramos ajustar la ventana. Para cambiar el tamaño de la ventana mantenemos pulsadas las teclas Ctrl + Alt y volvemos a pulsar la tecla numérica las veces que sea necesario hasta tener el tamaño que deseemos. Es decir, si pulsamos Ctrl+Alt+7 nos sitúa la ventana en la parte superior izquierda de la pantalla ocupando 1/9 de la misma.
Unity, emplea el plugin Grid de compiz anterior, pero modificado desde la versión 11.10 para que se comporte como ellos desean. En este vídeo se puede ver como se comporta este plugin manejándolo desde el teclado. Personalmente opino que mejor lo hubieran dejado como estaba.

Demostración del tiling básico del plugin de Compiz, Grid, en Ubuntu 11.10 con Unity

Gnome Shell, tiene un tiling muy básico parecido al que emplea Unity. Te permite maximizar una ventana o ajustarla a la mitad derecha/izquierda de la pantalla simplemente arrastrándola al borde correspondiente.
KDE a partir de la versión 4.4 tiene un tiling bastante conseguido, aunque no tan avanzado como los gestores dedicados. Desde luego es el escritorio que ha apostado más fuerte por este sistema y el que mejores resultados obtiene. Aunque no viene activarlo por defecto, es necesario activarlo a mano. De momento solo permite elegir entre dos esquemas predeterminados: columnas y espiral (fibonacci).

Aplicaciones que funcionan como un gestor

Para aquellos que no quieran instalar un gestor o no empleen uno de los entornos de escritorio anteriores, siempre existe la posibilidad de emplear alguna de estas aplicaciones que emulan el comportamiento básico de un gestor de ventanas de mosaico. Ambos son del tipo manual.

QuickTile, es un script en python que ofrece las mismas funcionalidades que el plugin Grid de Compiz.
x tile, es una aplicación instalable (viene en los repositorios de algunas distros) que ofrece más opciones que la anterior.

Gestores más populares

Hay muchos y para todos los gustos. Incluso los hay disponibles para otros SOs como Mac OS X o Windows (es muy famoso el WinSplit-Revolution para Windows, en el que se basa el plugin Grid, aunque los primeros gestores para linux son del 2000 y WinSplit aparece en el 2007). Me centrare aquí solo en los más populares.

awesome

Automático. Escrito en C y Lua, es configurable y extensible en Lua. Basado en dwm

Uno de los dos grandes, junto con Xmonad. Es quizá el que más opciones presenta hoy en día. Está basado en XCB en vez de Xlib, lo que le proporciona mayor agilidad. Aporta su propia barra de información, bandeja del sistema (systray) y lanzador de aplicaciones integrado. Tiene un soporte de ratón superior a la competencia. Pero su desarrollo no es aún solido, varía demasiado a lo largo de las distintas versiones y te obliga a reconfigurarlo cada vez que sale una nueva. Le he dedicado un articulo completo

bluetile

Automático. Escrito en Haskell. Basado en Xmonad

Es uno de los más sencillos de utilizar y de los más sencillos de probar. Es el más adecuado para probar por primera vez para los que se inician en esto. Está pensado para emplear conjuntamente con Gnome y pensando para que los están acostumbrados al ratón lo usen indistintamente con el teclado. En el siguiente vídeo realizado por su autor, Jan Vornberger, se puede ver como funciona:

dwm

Automático. Escrito, configurable y extensible en C.

Uno de los más ligeros, rápidos y simples. Su configuración se hace modificando su código fuente en C y luego hay que recompilarlo y reiniciarlo. Esto lo limita a usuarios avanzados con conocimientos de programación. Su diseño minimalista ha sido la inspiración para los dos más grandes: Awesome y Xmonad.

Para lanzar las aplicaciones se desarrolló dmenu un lanzador basado en texto, que es muy empleado en otros gestores. Funciona al igual que los lanzadores gráficos como Gnome Do.

i3

Manual. Escrito en C y configurable con ficheros de texto. Basado en wmii

Muy sencillo y que presume de estar bien documentado. Fácil de usar y configurar. Es manual, lo que le permite crear esquemas muy flexibles y personalizados, pero que por otro lado le resta comodidad.

wmii

Manual. Escrito en C y configurable en bash, rc, ruby o python

Escrito por el mismo desarrollador que dwm. Digamos que es el gestor equivalente a dwm pero manual.

xmonad

Automático. Escrito, extensible y configurable en Haskell. Inspirado en dwm

Muy potente, estable y con muchas opciones. Es altamente personalizable, con muchas extensiones disponibles. Se integra muy bien con Gnome y KDE. Tiene un desarrollo muy activo y una gran comunidad de usuarios detrás. Es el que empleo desde hace meses y le he dedicado un articulo completo.

Todos estos gestores están incluidos en los repositorios de Ubuntu, Debian, Gentoo y Arch Linux, y la mayoría están disponibles también en otras distribuciones.

Como curiosidad, mencionar otros dos, que aunque no son muy populares, están desarrollados en Python: tritium y qtile

Notificaciones de escritorio en Ubuntu desde Python

joe di castro — Sun, 12 Jun 2011 23:05:00 +0200

En Ubuntu¹ las notificaciones de escritorio son esos cuadros emergentes que nos proporcionan información sobre algún evento que se está produciendo en nuestro equipo (llegada de un email, canción que se está reproduciendo, cambio de volumen, estado de batería, etc). Sustituyen a las ventanas de dialogo que normalmente requieren la intervención del usuario para cerrarlas y son más molestas. Además frente a las ventanas de dialogo tienen la gran ventaja de que son gestionadas a través de una cola. Es decir, que si hay varias notificaciones para mostrar, no se muestran todas a la vez llenándote todo el escritorio de pequeñas ventanas, se van mostrando una después de otra. La notificaciones aparecen en una esquina del escritorio y se desvanecen por si solas al cabo de unos segundos. Son muy útiles porque llaman nuestra atención y nos informan sin interrumpir nuestro trabajo.

En Ubuntu esta operación la realiza el paquete Notify OSD que se basa en las especificaciones del proyecto Galago (freedesktop.org Desktop Notifications Specification). Este emplea el demonio notify-osd para enviar las notificaciones a través de D-Bus. Sin embargo muchos paquetes aún emplean la librería libnotify del proyecto Galago para enviar sus notificaciones. Además el proyecto Galago tiene un binding para Python de está librería, que es lo que emplearé en este artículo. En Ubuntu, es el paquete python-notify y se importa desde Python como pynotify. También es posible emplear el paquete libnotify-bin que nos proporciona el comando notify-send que nos permite enviar notificaciones directamente desde la línea de comandos, algo que puede ser muy útil para scripts en bash.

Ejemplo de utilización de notify-send:

$ notify-send "Notificación" "Esto es un ejemplo de notificación"

que nos mostraría una notificación como esta:

Notificaciones desde Python

Empleando pynotify podemos emplear estas notificaciones en nuestros programas y scripts Python y se visualizaran igual que las propias del sistema. El problema que tiene este modulo es que no tiene documentación AFAIK, por lo que tenemos que guiarnos por algunos ejemplos (los del propio paquete, por ejemplo) o experimentar con él ayudándonos de las herramientas de introspección de Python (help(), dir(), inspect).

Para poder emplearlo en mis programas he creado una función que hace uso de las opciones principales de las notificaciones:

import pynotify
import gtk

def notify(title, msg, icon=None):
    """Send notification icon messages through libnotify.

    Parameters:

    (str) title -- The notification title
    (str) msg -- The message to display into notification
    (str / uri) icon -- Type of icon (ok|info|error|warm|ask|sync) or icon file

    """
    if not pynotify.is_initted():
        pynotify.init(title)
    gtk_icon = {'ok':gtk.STOCK_YES, 'info':gtk.STOCK_DIALOG_INFO,
                'error':gtk.STOCK_DIALOG_ERROR, 'warm':gtk.STOCK_DIALOG_WARNING,
                'ask':gtk.STOCK_DIALOG_QUESTION, 'sync':gtk.STOCK_JUMP_TO}
    try:
        note = pynotify.Notification(title, msg)
        helper = gtk.Button()
        gtk_icon = helper.render_icon(gtk_icon[icon], gtk.ICON_SIZE_BUTTON)
        note.set_icon_from_pixbuf(gtk_icon)
    except KeyError:
        note = pynotify.Notification(title, msg, icon)
    note.show()

Básicamente llamamos a la función y le decimos que titulo le queremos poner, el mensaje y el icono que queremos mostrar. En cuanto al icono se puede emplear ninguno, uno personalizado indicando la ruta al fichero o un icono estándar de GTK para las opciones más comunes. Veamos lo sencillo de su funcionamiento con ejemplos:

>>> # Notificación sin icono
... notify("Titulo", "Esta notificación no lleva icono")
>>>

>>> # Notificación con icono personalizado
... notify("Ubuntu", "Esta lleva el icono personalizado",
"/usr/share/icons/gnome/scalable/places/ubuntu-logo.svg")
>>>

>>> # Notificación de información (GTK)
... notify("Información", "Esta emplea el icono de información estándar de GTK", "info")
>>>

>>> # Notificación de error (GTK)
... notify("Error!", "Ejemplo de reporte de error (GTK)", "error")
>>>

Como se puede ver el proceso es realmente sencillo y hacer esto puede aportar a nuestros programas/scripts ese toque que le faltaba y que tanto contribuye a la usabilidad de los mismos. Yo por ejemplo, lo empleo en scripts programados para saber cuando se activan y cuando terminan, sobre todo cuando son procesos largos. Un ejemplo puede verse en el código de Sincronizar una carpeta local y una remota a través de FTP: lftp-mirror

El fichero con este código, notify.py se encuentra en el repositorio Python Recipes alojado en github.

Se puede emplear también en otras distribuciones Linux ↩

Generar informes de cambios en paquetes instalados en Debian y Ubuntu.

joe di castro — Fri, 06 May 2011 22:55:00 +0200

Una de las políticas de seguridad que tengo con mis sistemas Linux, es además de efectuar respaldos periódicos (diarios) del contenido del directorio /home (en mi caso siempre es una partición o disco independiente), es siempre guardar también una lista de los paquetes instalados en los mismos. Prácticamente nunca hago una copia completa de la partición o disco de de sistema, y aunque si hago una copia de los directorios más importantes, prefiero tener siempre una relación actualizada de los paquetes instalados en cada maquina.

En sistemas Linux Debian y otras distribuciones derivadas (Ubuntu, Mint, Mepis, Knoppix, ...) obtener esta lista es realmente sencillo, pues solo es necesario ejecutar este comando:

dpkg -l > lista_paquetes.txt

Y con eso, se generaría una lista de los paquetes instalados¹ en el sistema en el fichero lista_paquetes.txt. Y mantener actualizado este fichero es tan sencillo como programar (via crontab por ejemplo) la ejecución de este comando con un sencillo script shell. Y así lo he realizado durante años, hasta que quise tener aun más información.

Entonces me interesó conocer también los cambios que se producen en los paquetes, es decir nuevas (des)instalaciones y actualizaciones. Es lógico pensar que si uno mismo es el que las realiza, pues ya sabe esta información de primera mano. Pero la memoria es frágil y no demasiado confiable, además ¿que ocurre cuando en una misma maquina tienen permisos para administrar los paquetes más de un usuario?

Se pueden conocer estos cambios de los paquetes en el tiempo de varios modos, desde acudir a los logs de dpkg en /var/log/dpkg.log y examinarlos con algún analizador de logs (o el más sencillo e inmediato comando less) hasta consultarlos de una manera más sencilla y gráfica con el gestor de paquetes Synaptic (en el menú Archivo -> Histórico). Pero me interesaba automatizar esto, para conocer esos cambios poco después de que se produjeran y lo lógico era emplear el mismo script shell que empleaba para generar la lista de paquetes instalados. Así lo hice entonces, combinando los comandos awk, grep, diff y mail con el comando del principio para obtener la lista, tenia los cambios en mi buzón de correo al poco tiempo de producirse. Y ha funcionado perfectamente hasta ahora.

Pero desde que me introduje en el lenguaje Python, he ido migrando poco a poco los scripts bash que tengo para reescribirlos en este lenguaje. Y recientemente le ha tocado a este. Ha sido muy fácil y la verdad es que el resultado aunque funcionalmente es el mismo, me ha permitido entregar unos informes más elegantes y fáciles de interpretar de un golpe de vista.

Ahora, cuando se realiza algún cambio en los paquetes del sistema, de forma automática, por mi o por otro usuario autorizado, yo recibo en mi correo un informe similar a este:

SCRIPT =========================================================================
dpkg_diff (ver. 0.1)
http://joedicastro.com

Changes of packages installed on yourmachine
 ===============================================================================

START TIME =====================================================================
                                                     Thursday 05/05/11, 10:30:01
 ===============================================================================

INSTALLED PACKAGES LIST FILE ___________________________________________________

/your/path/to/package_list.txt

CHANGES DIFF ___________________________________________________________________

--- previous Wed May  4 22:59:51 2011
+++ current  Thu May  5 10:30:01 2011
@@ -34,1 +34,1 @@
-ii  apt                 0.7.25.3ubuntu9.3
+ii  apt                 0.7.25.3ubuntu9.4
@@ -36,2 +36,2 @@
-ii  apt-transport-https 0.7.25.3ubuntu9.3
-ii  apt-utils           0.7.25.3ubuntu9.3
+ii  apt-transport-https 0.7.25.3ubuntu9.4
+ii  apt-utils           0.7.25.3ubuntu9.4

END TIME =======================================================================
                                                     Thursday 05/05/11, 10:30:01
 ===============================================================================

Donde se puede ver la información que nos indica el script que ha generado el correo, la maquina en la que se han realizado los cambios, la localización del fichero con la relación de todos los paquetes instalados en el sistema, la fecha y hora de la ejecución del script y el diff con la relación de cambios en los paquetes en formato Unified format. En este ejemplo podemos ver como se han actualizado tres paquetes en esa maquina. No nos dice la hora en que se efectuó la modificación (podemos verlo en el log de dpkg) pero si podemos saber que se efectuó entre dos intervalos de ejecución del script, información que será más que suficiente la mayoría de las veces. Para datos concretos, ir al log y filtrarlo con grep y en segundos sabremos la respuesta. Si además como es mi caso, ejecutamos el script cada 12 o 24 horas, pues será fácil saber cuando se han realizado los cambios.

Un fragmento de código de la parte principal del script es el siguiente:

def pretty_diff(diff):
    """Better format for package lines in diff."""
    pkg = {} # diff's packages lines

    # Get columns info for diff package lines
    for idx, line in enumerate(diff):
        if not findall("^-{3}|^\+{3}|^@{2}", line):
            # split the line in columns and remove the description column
            cols = split("\s{2,}", line, 3)[:3]
            # A nested dict, for each line index we have a dict that contains 
            # the package line columns: 's' (status), 'n' (name) & 'v' (version)
            # and the width of the name column: w(width)
            pkg[idx] = {'s':cols[0], 'n':cols[1], 'v':cols[2], 'w':len(cols[1])}

    # maximum width in packages' name column for all lines
    mxw = max((pkg[index]['w'] for index in pkg))

    # Replace each package line for a prettier one (more legible) 
    for i in range(len(diff)):
        if i in pkg:
            diff[i] = ("{0} {1} {2}".format(pkg[i]['s'], pkg[i]['n'] + " " *
                                            (mxw - pkg[i]['w']), pkg[i]['v']))
    return diff

def main(old=""):
    """Main section"""

    # The path to store the debian packages list file
    pkg_lst_file = "./package_list.txt"

    # Start logging
    log = Logger()
    url = "http://joedicastro.com"
    head = "Changes of packages installed on {0}".format(platform.node())
    log.header(url, head)
    log.time("Start time")

    # Read the old file and clean the list
    if os.path.exists(pkg_lst_file):
        old = open(pkg_lst_file, 'r').readlines()
        old_date = time.ctime(os.stat(pkg_lst_file).st_mtime)

    # Get the current list of debian packages installed on system 
    current = Popen(["dpkg", "-l"], stdout=PIPE).stdout.readlines()

    # First, save the list file
    with open(pkg_lst_file, 'w') as out:
        out.writelines(current)
        curr_date = time.ctime(os.stat(pkg_lst_file).st_mtime)

    # Compare both lists
    if old:
        file_path = os.path.realpath(pkg_lst_file)
        diff = [ln for ln in unified_diff(old, current, fromfile="previous",
                                          tofile="current ",
                                          fromfiledate=old_date,
                                          tofiledate=curr_date, n=0,
                                          lineterm="")]

        # If there are differences write the log to disk and send mail
        if diff:
            log.list("Installed packages list file", file_path)
            log.list("Changes diff", pretty_diff(diff))
            log.time("End time")
            log.write(True)
            # Send mail to current system user. For other options, see logger 
            # module info
            log.send("Debian packages changes")

Este script hace uso del modulo logger, que comento en este artículo.

Para obtener la versión más reciente del script y del modulo logger, consultar mi repositorio Python Recipes en github.

Es una relación de los programas instalados empleando el sistema de paqueteria de Debian, los programas instalados manualmente vía compilación u otros medios no aparecerán en ella. ↩