Behind open doors

En la anterior entrada, vimos como añadir el tiempo de nuestra ciudad, al menú de openbox: http://behindopendoors.netne.net/blog/linux/ver-el-clima-de-nuestra-ciudad-en-openbox.

Ahora, vamos a visualizarlo, usando el mismo script pero mediante conky, por lo que lo podremos usar en cualquier distro y entorno de escritorio, solo tendremos que instalar previamente conky (lo encontraréis en repositorios).

Lo primero, tendremos que usar, el script escrito en python, que modificado un poco (copiad el texto, y pegarlo en un archivo). Yo lo guardo en la ruta ~/.config/openbox/scripts/gweather-conky2.py, pero podéis ponerlo donde queráis.

#!/usr/bin/python -o
# -*- coding: utf-8 -*-

from  urllib import urlopen, quote
from xml.etree.cElementTree import parse
from  datetime import datetime, timedelta
import os
from os.path import  join
from sys import argv
try:
import cPickle as pickle
except  ImportError:
import pickle

TRANSLATED_TEXT = {
'en': {
'current': 'Current conditions',
'weather': 'Weather',
'temp': 'Temperature',
'humidity': 'Humidity',
'wind': 'Wind',
'forecast': 'Forecast',
'mintemp': 'Minimun Temperature',
'maxtemp': 'Maximun Temperature'
},
'es': {
'current': u'Actualmente',
'weather': u'Tiempo',
'temp': u'Temperatura',
'humidity': u'Humedad',
'wind': u'Viento',
'forecast': u'Previsión',
'mintemp': u'Temperatura Mínima',
'maxtemp': u'Temperatura  Máxima'
},
'fr': {
'current': u'Actuel',
'weather': u'Météo',
'temp': u'Température',
'humidity': u'Humidité',
'wind': u'Vent',
'forecast': u'Prévision',
'mintemp': u'Température minimale',
'maxtemp': u'Température maximale'
},
'de': {
'current': u'Aktuell',
'weather': u'Wetter',
'temp': u'Temperatur',
'humidity': u'Luftfeuchtigkeit',
'wind': u'Wind',
'forecast': u'Prognostizieren',
'mintemp': u'Minimale Temperatur',
'maxtemp': u'Höchste  Temperatur'
}
}

if len(argv) != 3:
raise  Exception('Usage: gweather.py city language.')
else:
city =  argv[1]
lang = argv[2]

CACHE_HOURS = 1

WEATHER_URL  = 'http://www.google.com/ig/api?weather=%s&hl=%s&oe=UTF-8'

def  get_weather(city, lang):
url = WEATHER_URL % (quote(city),  quote(lang))
data = parse(urlopen(url))

forecasts =  []
for forecast in data.findall('weather/forecast_conditions'):
forecasts.append(
dict([(element.tag, element.get("data"))  for element in forecast.getchildren()]))

return {
'forecast_information': dict([(element.tag, element.get("data"))  for element in  data.find('weather/forecast_information').getchildren()]),
'current_conditions': dict([(element.tag, element.get("data")) for  element in data.find('weather/current_conditions').getchildren()]),
'forecasts': forecasts
}

def  get_openbox_pipe_menu(lang, forecast_information, current_conditions,  forecasts):
if lang == 'en-US':
lang = 'en'

tt = TRANSLATED_TEXT[lang]

temp_var, temp_unit =  ("temp_c", u"\u00b0C") if forecast_information['unit_system'] == "SI"  else ("temp_f", "F")

output = ''

output += '%s\n' % (current_conditions['condition'])
output += '%s: %s %s\n' % (tt['temp'], current_conditions[temp_var], temp_unit)
output += '%s\n' % (current_conditions['humidity'])
output += '%s' % (current_conditions['wind_condition'])return output.encode('utf-8')

cache_file =  join(os.getenv("HOME"), '.gweather-conky2.cache')

try:
f =  open(cache_file,'rb')
cache = pickle.load(f)
f.close()
except  IOError:
cache = None

if cache == None or (city, lang)  not in cache or (
cache[(city, lang)]['date'] +  timedelta(hours=CACHE_HOURS) < datetime.utcnow()):
# The cache  is outdated
weather = get_weather(city, lang)
ob_pipe_menu = get_openbox_pipe_menu(lang, **weather)
print  ob_pipe_menu
if cache == None:
cache = dict()
cache[(city, lang)] = {'date': datetime.utcnow(), 'ob_pipe_menu':  ob_pipe_menu}

#Save the data in the cache
try:
f = open(cache_file, 'wb')
cache = pickle.dump(cache,  f, -1)
f.close()
except IOError:
raise
else:
print cache[(city, lang)]['ob_pipe_menu']

Bien, ahora tenemos que crear el archivo de configuración de conky:

# set to yes if you want Conky to be forked in the background
background yes

# Use Xft?
use_xft yes
xftfont Dejavu Sans:pixelsize=11

# Update interval in seconds
update_interval 1

# This is the number of times Conky will update before quitting.
# Set to zero to run forever.
total_run_times 0

# Create own window instead of using desktop (required in nautilus)
own_window  yes
own_window_transparent yes
own_window_type normal
own_window_hints undecorate,below,sticky,skip_taskbar,skip_pager

# Use double buffering (reduces flicker, may not work for everyone)
double_buffer yes

# Minimum size of text area
minimum_size 160
maximum_width 200

# Draw shades?
draw_shades no

# Draw outlines?
draw_outline no

# Draw borders around text
draw_borders yes

# Stippled borders?
stippled_borders 0

# border margins
border_margin 3

# border width
border_width 0

# Default colors and also border colors
default_color 404040
#default_shade_color white
#default_outline_color black
own_window_colour 3c3c3c

# Text alignment, other possible values are commented
#alignment top_left
alignment top_right
#alignment bottom_left
#alignment bottom_right

# Gap between borders of screen and text
# same thing as passing -x at command line
gap_x 15
gap_y 70

# Subtract file system buffers from used memory?
no_buffers yes

# set to yes if you want all text to be in uppercase
uppercase yes

# number of cpu samples to average
# set to 1 to disable averaging
cpu_avg_samples 2

# number of net samples to average
# set to 1 to disable averaging
net_avg_samples 2

# Force UTF8? note that UTF8 support required XFT
override_utf8_locale yes

# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer right
TEXT
${color #000000}${execi 12 python ~/.config/openbox/scripts/gweather-conky2.py bilbao es;}

Este archivo, lo guardais con el nombre de .conkyrc, y lo ponéis en vuestra home. Si queréis, podéis usar más de un conky al mismo tiempo (este solo os dará el tiempo, a no ser que le añadáis código).

Tenéis que prestar especial atención a la última linea del conky: ${color #000000}${execi 12 python ~/.config/openbox/scripts/gweather-conky2.py bilbao es;} . Podéis cambiar el color, variando los números, la frecuencia con la que se ejecuta el script (12 segundos por defecto, aunque el script de python no se refresca con tanta frecuencia), la ruta donde dejasteis el script (editarla correctamente) y por último, el nombre de vuestra ciudad (si tiene espacios, poner un guión, por ejemplo: buenos-aires), y por el último, poned es, que es el idioma, no el país de vuestra ciudad.

Si todo ha ido bien, lograréis el siguiente efecto:

Se puede modificar el script de python, para que nos muestre otros datos, o los ordene de otra manera, si sabéis un poco de programación básica, no os será difícil. También podéis añadir datos de temperatura, voltaje y velocidad de los ventiladores: http://behindopendoors.netne.net/blog/linux/lm-sensors-monitoriza-la-temperatura-velocidad-de-los-ventiladores-y-sus-voltajes

Tepes General Arch, clima, conky, Linux, liviano, Opebox, python, script

Puede que algo tan sencillo como ver el clima de nuestra ciudad, en nuestro entorno de escritorio, se complique. Seguramente habrá un montón de opciones, yo os voy a ofrecer una liviana, fácil de configurar, y que a mí me parece elegante. Una imagen vale más que mil palabras, así que…

Para incluir el clima en el menú de openbox, usé un script escrito en python, que posteó un usuario en el foro de Arch: http://bbs.archlinux.org/viewtopic.php?id=43432.

El script:

#!/usr/bin/python -o
# -*- coding: utf-8 -*-

from urllib import urlopen, quote
from xml.etree.cElementTree import parse
from datetime import datetime, timedelta
import os
from os.path import join
from sys import argv
try:
import cPickle as pickle
except ImportError:
import pickle

TRANSLATED_TEXT = {
'en': {
'current': 'Current conditions',
'weather': 'Weather',
'temp': 'Temperature',
'humidity': 'Humidity',
'wind': 'Wind',
'forecast': 'Forecast',
'mintemp': 'Minimun Temperature',
'maxtemp': 'Maximun Temperature'
},
'es': {
'current': u'Actualmente',
'weather': u'Tiempo',
'temp': u'Temperatura',
'humidity': u'Humedad',
'wind': u'Viento',
'forecast': u'Previsión',
'mintemp': u'Temperatura Mínima',
'maxtemp': u'Temperatura Máxima'
},
'fr': {
'current': u'Actuel',
'weather': u'Météo',
'temp': u'Température',
'humidity': u'Humidité',
'wind': u'Vent',
'forecast': u'Prévision',
'mintemp': u'Température minimale',
'maxtemp': u'Température maximale'
},
'de': {
'current': u'Aktuell',
'weather': u'Wetter',
'temp': u'Temperatur',
'humidity': u'Luftfeuchtigkeit',
'wind': u'Wind',
'forecast': u'Prognostizieren',
'mintemp': u'Minimale Temperatur',
'maxtemp': u'Höchste Temperatur'
}
}

if len(argv) != 3:
raise Exception('Usage: gweather.py city language.')
else:
city = argv[1]
lang = argv[2]

CACHE_HOURS = 1

WEATHER_URL = 'http://www.google.com/ig/api?weather=%s&hl=%s&oe=UTF-8'

def get_weather(city, lang):
url = WEATHER_URL % (quote(city), quote(lang))
data = parse(urlopen(url))

forecasts = []
for forecast in data.findall('weather/forecast_conditions'):
forecasts.append(
dict([(element.tag, element.get("data")) for element in forecast.getchildren()]))

return {
'forecast_information': dict([(element.tag, element.get("data")) for element in data.find('weather/forecast_information').getchildren()]),
'current_conditions': dict([(element.tag, element.get("data")) for element in data.find('weather/current_conditions').getchildren()]),
'forecasts': forecasts
}

def get_openbox_pipe_menu(lang, forecast_information, current_conditions, forecasts):
if lang == 'en-US':
lang = 'en'

tt = TRANSLATED_TEXT[lang]

temp_var, temp_unit = ("temp_c", u"\u00b0C") if forecast_information['unit_system'] == "SI" else ("temp_f", "F")

output = ''
output += '\n' % (weather['forecast_information']['city'],forecast_information['forecast_date'])
output += '\n' % tt['current']
output += '' % (tt['weather'], current_conditions['condition'])
output += '' % (tt['temp'], current_conditions[temp_var], temp_unit)
output += '' % (tt['humidity'], current_conditions['humidity'])
output += '' % (tt['wind'], current_conditions['wind_condition'])
for forecast in forecasts:
output += '\n' % (tt['forecast'], forecast['day_of_week'])
output += '' % (tt['weather'], forecast['condition'])
output += '' % ( tt['mintemp'], forecast['low'], temp_unit )
output += '' % ( tt['maxtemp'], forecast['high'], temp_unit )
output += '\n'

return output.encode('utf-8')

cache_file = join(os.getenv("HOME"), '.gweather.cache')

try:
f = open(cache_file,'rb')
cache = pickle.load(f)
f.close()
except IOError:
cache = None

if cache == None or (city, lang) not in cache or (
cache[(city, lang)]['date'] + timedelta(hours=CACHE_HOURS) < datetime.utcnow()):
# The cache is outdated
weather = get_weather(city, lang)
ob_pipe_menu = get_openbox_pipe_menu(lang, **weather)
print ob_pipe_menu
if cache == None:
cache = dict()
cache[(city, lang)] = {'date': datetime.utcnow(), 'ob_pipe_menu': ob_pipe_menu}

#Save the data in the cache
try:
f = open(cache_file, 'wb')
cache = pickle.dump(cache, f, -1)
f.close()
except IOError:
raise
else:
print cache[(city, lang)]['ob_pipe_menu']

Lo guardamos en el directorio que queramos, yo lo dejé en ~/.config/openbox/scripts/gweather.py, pero da lo mismo. Para ejecutarlo:

python ~/.config/openbox/scripts/gweather.py YOURCITY IDIOMA

El idioma, podemos escoger entre es, de, fr, o de. Y el nombre de nuestra ciudad en minúsculas, si tiene espacios lo pondremos con un guión de la siguiente forma: buenos-aires.

Ahora vamos a insertar el script en el menú de openbox, de la siguiente manera, editando el archivo ~/.config/openbox/menu.xml:
añadimos la siguiente linea, donde queramos que aparezca en el menú (a nuestro gusto).

<menu id="pipe-weather" label="Weather" execute="python ~/.config/openbox/scripts/gweather.py bilbao es" />

Y ya está todo listo. Este script lo podemos usar con otras aplicaciones, modificando el output editando el codigo python, o con pipes, el único limite es nuestra imaginación (y los conocimientos de programación). En el proximo artículo, explicaré como usarlo conjuntamente con el monitor del sistema conky.

P.D: Agradecer al autor, o autores que se han currado el script, y espero que funcione por mucho tiempo y no cambien la web .

Tepes Archlinux, Linux Arch, clima, Linux, liviano, Openbox, python, script

Sin profundizar demasiado en el tema, voy a explicar como maneja Linux los permisos de archivos, para entender como funciona, y poder configurarlo fácilmente.

Si lo que queréis es la versión extendida, aquí os dejo un par de enlaces, en los que se explica de una manera más completa:
http://www.ant.org.ar/cursos/curso_intro/x1439.html

Voy a empezar, explicándolo de una manera gráfica, que seguro que es algo más intuitiva. Cuando abrimos las propiedades con el botón derecho del ratón, en cualquier archivo o directorio, veremos una pantalla como esta:

En nautilus: (a mi parecer, un poco complicada su forma de visualización)

En pcmanfm: (más sencillo imposible)

Bien, ahora vamos a ver que significa cada parte:

Hay tres secciones, el propietario, el grupo, y los otros usuarios que no pertenecen al grupo marcado. Cada uno de estos colectivos, tiene tres clases de permisos. Lectura (poder leer el archivo), escritura (editar, y borrar el archivo), y ejecución (el archivo podrá ser ejecutado). Estas opciones pueden aplicarse a un archivo, o a un directorio.

En las imágenes mostradas arriba, podemos ver un directorio que se encuentra en mi partición de datos, que alberga música. El propietario soy yo, con permisos de lectura, escritura, y ejecución, mientras que los demás usuarios, pueden escuchar esa música, pero no borrarla o editarla, de manera que podemos estar tranquilos.

Solo podremos cambiar los permisos, de los archivos y directorios que seamos dueños (a no ser que los editemos como root), lógico no? Bien, ahora que ya hemos entendido como funcionan los permisos, vamos a profundizar un poco, y ver como gestionarlos desde la terminal (puede sernos muy útil).

Con el comando, ls -la (ls para listar, -l para mostrar los permisos, y -a para mostrar archivos ocultos), veremos una lista como esta en cualquier directorio (cojo los ejemplos de ant.org):

[shrek@pantano:~]$ ls -la
total 13
drwxr-sr-x   2 shrek    user        1024 May  2 09:04 .
drwxrwsr-x   4 root     staff       1024 Apr 17 21:08 ..
-rw-------   1 shrek    user        2541 May  2 22:04 .bash_history
-rw-r--r--   1 shrek    user         164 Apr 23 14:57 .bash_profile
-rw-r--r--   1 shrek    user          55 Apr 23 14:44 .bashrc
-rwxrwxr-x   1 shrek    user           0 Apr 14 19:29 a.out
-rwxrwxr-x   1 shrek    user          40 Apr 30 12:14 hello.pl
-r--------   1 shrek    user          64 Apr 29 14:04 hola
-rwxrw-r--   1 shrek    user         337 Apr 29 13:57 lista
-rw-rw-r--   1 shrek    user         40  Apr 30 12:31 listador
-rw-rw-r--   1 shrek    user           0 May  2 09:04 null
-rwxrwxr-x   1 shrek    user         175 Apr 30 12:30 prue.pl
-rwxrwxr-x   1 shrek    user          56 Apr 23 15:08 que.sh

Vemos, que se listan 10 caracteres, que nos dan la información que necesitamos, vamos a verlo uno por uno, una vez entendido, es muy fácil de interpretar. El primero, nos dice que tipo de archivo o directorio es:

Ahora vamos, a ver que significan los siguientes caracteres, que son los que nos importan:

Como veis, es lo mismo que nos mostraba la interface gráfica, 3 subgrupos, de 3 caracteres, el primero es permiso de lectura (r de read), el segundo escritura (w de write), y el tercero de ejecución (x execute).

Para cambiar los permisos, usaremos el comando chmod en una terminal. Agregaremos permisos con el símbolo mas “+” y los quitaremos con el símbolo “-”. También tenemos que especificar a que grupo se los estamos aplicando, al propietario:

a: aplicar a todos

u: aplicar al propietario

g: aplicar al grupo

o: aplicar a terceros

Pongo un par de ejemplos, para que se entienda mejor:

chmod a+x archivo

Le estaremos agregando permisos de ejecución (x), para todos.

chmod go-w archivo

Ahora en cambio, le estamos quitando los permisos de escritura (w), a los miembros del grupo, y a terceros

De todas, maneras, hay una manera más sencilla, de hacer estos cambios, y es usando el sistema octal. Para los que sepáis un poco de matemáticas, o tengáis curiosidad, os explico de donde salen los números que vamos a ver a continuación. Con este sistema, a cada privilegio, se le aplica un número, siguiendo el sistema octal: el bit x es 2⁰ = 1, el bit w es 2¹ = 2, el bit r es 2² = 4.

Resumiendo:
r = 4
w = 2
x = 1

Ahora haciendo simples sumas, podemos nombrar cualquier permisos mediante números de 3 dígitos (el primero para el propietario, el segundo para el grupo, y el tercero para terceros).

Solo tenemos que sumar los ingredientes que queramos, para saber el número que debemos aplicar, es bastante sencillo y fácil de recordar. Luego aplicamos el valor, con el comando chmod:

chmod 755 archivo

Ahora, por últimos, vamos a ver como cambiar el propietario o el grupo al que pertenece un archivo. Lo haremos con el comando chown. Indicaremos el nombre del propietario nuevo, y también podemos agregar seguido de un punto, el nombre del grupo, si queremos cambiarlo.

chown pepito archivo.txt

Nombra a pepito propietario del archivo

chown pepito.amigos archivo.txt

Nombra a pepito propietario del archivo y además cambia el grupo a “amigos”.

chown .amigos archivo.txt

Cambia el grupo a “amigos”, pero mantiene el mismo propietario de archivo.

Eso es todo. Esto nos servirá para entender mejor como maneja linux los permisos, y poder solucionar pequeños errores que nos encontremos, o administrar mejor nuestro sistema, sobretodo si hay más de un usuario en el mismo, y no queremos llevarnos sorpresas.

Tepes Linux Linux, nautilus, pcmanfm, permisos, seguridad

Esto, no pretende ser un tutorial sobre openbox, solamente escribo una especie de notas para recordarme los programas que uso en openbox para futuras instalaciones (es lo que tiene tener un poco memoria pez).

Como veis, hace unos días, dí el salto a openbox, y deje atrás gnome. La idea era ganar algo de rendimiento (sobretodo en el netbook), aunque también, cambiar un poco la imágen de Arch, ya que llevo desde que empecé en linux usando Gnome.

Openbox me ha parecido la mejor opción después de probar varios entornos, gestores de ventanas etc. Es lígero, muy configurable y flexible, y no pierde funcionalidades frente a Gnome, siempre que se configure correctamente. Además, me parece muy estético. Bueno sin más dilación, os dejo un link, con una guía muy completa, de la mano de Xabz: http://archxz.wordpress.com/2009/09/12/guia-openbox/ . Con alguna manita extra de google, obtendremos información de todo lo que queramos. También tuve un problema con los pendrives, que lo relaté en este otro post: http://behindopendoors.netne.net/blog/linux/montar-pendrives-en-openbox.

Aplicaciones de configuración:
obconf (para configurar diversas opciones de openbox)
obkey-git(configura las convinaciones de teclas, "shortcuts")
openbox-themes (paquetes con temas de openbox)
lxappearance (configura los temas GTK)
obmenu (una forma sencilla de editar nuestro menú de openbox)
lx-randr (configura la resolución de pantalla)

Accesorios:
oblogout (pantalla para gestionar el apagado, reinicio...)
fb-panel (un panel ligero y configurable)

Otros:
sakura (terminal)
evince (visor de documentos, pdf)
scrot (capturador de pantalla, screenshots)
galcultator (calculadora)
gpicview (visor de imágenes
xscreensaver (salvapantallas)
slim (gestor de entrada)
pcmanfm (navegador de archivos)
xfburn (grabador de CD, DVD)
moc (reproductor de música muy ligero, para la terminal)
xmms2 (reproductor de música ligero)
midori (navegador web ligero)
notify-osd (muestra notificaciones con un aspecto elegante)

Estos son todos los programas de nueva adquisición. Todos los he elegido buscando que sean ligeros, pero sin perder usabilidad. De todas maneras, sigo usando otros programas, como emesene, deluge, vlc, firefox, amarok… que no son precisamente los más ligeros.

Actualización:

Añado unos links muy interesantes de la mano de Ramón:

http://www.glatelier.org/2010/01/escritorio-kiss/

http://urukrama.wordpress.com/openbox-guide/ (en inglés)

http://skinwalker.wordpress.com/ (en inglés, más que nada parte estética)

Tepes Archlinux, Linux liviano, Openbox, programas

Después de actualizar mi sistema en Arch, al arrancar el equipo, no me encontraba ninguna IP. Inicie dhcpcd desde una terminal, y me dice lo siguiente:

sudo dhcpcd
dhcpcd: version 5.1.4 starting
dhcpcd: eth0: broadcasting for a lease
dhcpcd: timed out

Entoncés fuí al foro de Arch, y N0dix, dió con la solución. En este post (en inglés) hablan sobre ello: http://bbs.archlinux.org/viewtopic.php?pid=688104
Para solucionarlo, solo hay que borrar el archivo /var/lib/dhcpcd/dhcpcd-eth0.lease. Nosotros vamos a renombrarlo por si acaso:

sudo mv /var/lib/dhcpcd/dhcpcd-eth0.lease /var/lib/dhcpcd/dhcpcd-eth0.lease.backup

Fijaros en el nombre de la interface que vais a editar, si usáis otra para internet, editad la correspondiente (cambiad et0, por wlan0, eth1… o lo que corresponda). Y ya está, solo nos queda volver a iniciar dhcpcd:

sudo dhcpcd
dhcpcd: version 5.1.4 starting
dhcpcd: eth0: rebinding lease of XX:XXX:XXX:X
dhcpcd: eth0: acknowledged XX:XXX:XXX:X from XX:XXX:XXX:X
dhcpcd: eth0: checking for XX:XXX:XXX:X
dhcpcd: eth0: leased XX:XXX:XXX:X for 86400 seconds
dhcpcd: forking to background

Eso es todo. Una rápida solución, a un problema que pintaba muy feo.

Tepes Archlinux, Linux Arch, bug, dhcpcd, ip, Linux

Voy a comentar brevemente, un problemilla que he tenido en mi salto a openbox, y como he logrado solucionarlo (gracias a Teh, del foro de Arch). El problema, era que cuando quería montar un pendrive desde el explorador de archivos (sea cual fuera), no funcionaba con un doble click de toda la vida. Me tiraba el siguiente error:

Rejected send message, 1 matched rules; type="method_call", sender=":1.7"
 (uid=1000 pid=3278 comm="pcmanfm) interface="org.freedesktop.Hal.Device.
Volume" member="Mount" error name="(unset)" requested_reply=0
destination="org.freedesktop.Hal" (uid=0 pid=825 comm="/usr/sbin/hald))

Parece ser que es problema de Hal, y la solución más sencilla, me ha parecido añadir un par de lineas al fstab:

sudo nano /etc/fstab

 /dev/sdb1 /media/pen auto   rw,users,noauto 0 0
 /dev/sdc1 /media/pen2 auto  rw,users,noauto 0 0

Añado dos lineas, por si conectamos dos pendrives a la vez, el primero lo reconocerá como sdb1, y el segundo como sdc1.

También tenemos que crear los dos puntos de montaje:

sudo mkdir /media/pen1 /media/pen2

Los puntos de montajes, los podéis cambiar, así como las opciones del fstab. Es solo para que os hagáis una idea. De esta manera, ya podremos montar los pendrives con un doble click.

Tepes Archlinux, Linux Arch, Hal, Linux, mount, Openbox, pcmanfm, pendrive

Hace poco expliqué una manera sencilla para crear un pendrive-live de ubuntu: http://behindopendoors.netne.net/blog/linux/crear-un-pendrive-live-de-ubuntu. En archlinux en cambio, vamos a hacerlo a mano, desde la consola, con un par de comandos, de una manera bastante sencilla. De esta forma, lograremos meter nuestra distro favorita en un pendrive, que nos será necesario para instalar Arch en un pendrive.

Lo primero que tenemos que hacer, es conseguir una imágen del cd de arch. Yo suelo usar las netinstall, que trae solo lo básico, y el resto lo descarga de internet, más actualizado, pero bueno, eso a vuestro gusto.

Ahora desde la consola, y en la ruta donde tengamos la imágen de arch, le vamos a indicar donde copiar la imágen, con el siguiente comando (lean atentamente antes de hacer nada):

dd if=archlinux-2009.08-netinstall-i686.img of=/dev/sdX

Si queréis saber más sobre el comando if, en este post lo explican (aunque el post sea sobre como duplicar un disco duro: http://www.entiendeatux.com/2010/02/16/breve-copia-exacta-de-un-hd-a-otro-hd/)Le tenemos que indicar el nombre del archivo de la imágen que tengamos, y la ruta donde está el pendrive. Normalmente es /dev/sdb1, pero podéis comprobarlo ejecutando el comando blkid. Tened cuidado de no indicar el dispositivo que no es, porque podéis perder datos. Si tenéis conectado algún disco duro externo, yo lo desconectaría por precaución (más vale prevenir que curar, sobretodo si somos un poco manazas .

Los datos de la imágen de arch, ocupan muy poco. Así que en el espacio restante, podemos crear otra partición, para guardar otros archivos que queramos llevar en el llavero. Esto lo podemos hacer con cualquier editor de particiones (yo uso gparted).

Y ya tenemos listo nuestro usb-live con arch.

Este tip lo leí en un artículo del blog de Leonardo Andrés Gallego, en el que explica como instalar archlinux en una netbook (http://www.hombrepac.com.ar/articulos/instalando-arch-linux-2009-08-con-kde-4-3-en-la-netbook-asus-eeepc-1000ha/ ), y me pareció bueno comentar esta parte, para poder tenerla a mano.

Tepes Archlinux, Linux Archlinux, instalar, Linux, pendrive, usb