miércoles, 30 de diciembre de 2015

Cortando, copiando y pegando texto

El comando d no sólo borra texto, también “corta” texto. Cada vez que usamos el comando d lo borrado se copia en un buffer de pegado (el portapapeles) que luego podremos recuperar con el comando p, para pegar el contenido del buffer tras el cursor, o el comando P, para pegar el contenido antes del cursor.

El comando y se usa para “yank” (copiar) texto de forma muy parecida a la que el comando d usa para cortar texto. Aquí tienes algunos ejemplos combinando el comando y con varios comandos de movimiento:

Tabla 13-4: Comandos de copiado
Comando Copia
yy La línea actual.
5yy La línea actual y las siguientes cuatro líneas.
yW Desde la posición actual del cursor hasta el principio de la siguiente palabra.
y$ Desde la posición actual del cursor al final de la línea actual.
y0 Desde la posición actual del cursor hasta el principio de la línea.
y^ Desde la posición actual del cursor hasta el primer espacio no en blanco de la línea.
yG Desde la línea actual hasta el final del archivo.
y20G Desde la línea actual hasta la vigésima línea del archivo.

Probemos algunos copiados y pegados. Coloca el cursor en la primera línea del texto y pulsa yy para copiar la línea actual. A continuación, mueve el cursor a la última línea (G) y pulsa p para pegar la línea debajo de la línea actual:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5
The quick brown fox jumped over the lazy dog. It was cool.

Al igual que antes, el comando u deshará nuestro cambio. Con el cursor posicionado todavía en la última línea del archivo, pulsa P para pegar el texto sobre la línea actual:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
The quick brown fox jumped over the lazy dog. It was cool.
Line 5

Prueba algunos otros comandos y de la tabla anterior y trata de comprender el funcionamiento de los comandos p y P. Cuando lo hayas hecho, vuelve el archivo a su estado original.

martes, 29 de diciembre de 2015

Borrando texto

Como era de esperar, vi ofrece varias formas de borrar texto, todas ellas compuestas por la pulsación de una o dos teclas. Primero, la tecla x borrará un carácter en la localización del cursor. x debería ir precedida por un número especificando cuantos caracteres van a ser borrados. La tecla d es de propósito más general. Como x, debería ir precedida por un número especificando el número de veces que se realizará el borrado. Además, d siempre va seguido por un comando de movimiento que controla el tamaño del borrado. Aquí tenemos algunos ejemplos:

Tabla 12-3: Comandos de borrado de texto
Comando Borra
x El carácter actual.
3x El carácter actual y los siguientes dos caracteres.
dd La línea actual.
5dd La línea actual y las cuatro siguientes.
dW Desde la posición actual del cursor hasta el principio de la siguiente palabra.
d$ Desde la posición actual del cursor hasta el final de la línea actual.
d0 Desde la posición actual del cursor hasta el principio de la línea.
d^ Desde la posición actual de cursor hasta el primer carácter no en blanco de la línea.
dG Desde la línea actual al final del archivo.
d20G Desde la línea actual hasta la vigésima línea del archivo.

Coloca el cursor en la palabra “It” en la primera línea de nuestro texto. Pulsa la tecla x repetidamente hasta que el resto de la frase se borre. A continuación, pulsa la tecla u repetidamente hasta que se deshaga el borrado.

Nota: El auténtico vi sólo soporta un único nivel de deshacer. vim soporta múltiples niveles.

Probemos el borrado de nuevo, esta vez usando el comando d. De nuevo, mueve el cursor a la palabra “It” y pulsa dW para borrar la palabra:

The quick brown fox jumped over the lazy dog. was cool.
Line 2
Line 3
Line 4
Line 5

Pulsa d$ para borrar desde la posición del cursor hasta el final de la línea:

The quick brown fox jumped over the lazy dog.
Line 2
Line 3
Line 4
Line 5

Pulsa dG para borrar desde la línea actual hasta el final del archivo:

~
~
~
~
~

Pulsa u tres veces para deshacer el borrado.

lunes, 28 de diciembre de 2015

Abriendo una línea

Otra forma en que podemos insertar texto es “abriendo” una línea. Esto inserta una línea en blanco entre dos líneas existentes y entra en el modo inserción. Tiene dos variantes:

Tabla 12-2: Teclas de apertura de líneas
Comando Abre
o La línea bajo la línea actual.
O La línea sobre la línea actual.

Podemos demostrar esto de la siguiente forma: coloca el cursor en la “Línea 3” y luego pulsa la tecla o.

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3

Line 4
Line 5

Una nueva línea se abre bajo la tercera línea y entramos en el modo inserción. Salimos del modo inserción pulsando la tecla Esc. Pulsamos la tecla u para deshacer nuestro cambio.

Pulsa la tecla O para abrir la línea sobre el cursor.

The quick brown fox jumped over the lazy dog. It was cool.
Line 2

Line 3
Line 4
Line 5

Salimos del modo inserción presionando la tecla Esc y deshaciendo nuestro cambio pulsando u.

miércoles, 23 de diciembre de 2015

Añadiendo texto

vi tiene varias formas para entrar en el modo inserción. Ya hemos usado el comando i para insertar texto.

Volvamos a nuestro archivo foo.txt un momento:

The quick brown fox jumped over the lazy dog.

Si quisiéramos añadir texto al final de esta frase, descubriríamos que el comando i no lo hace, ya que no podemos mover el cursor más allá del final de la línea. vi cuenta con un comando para añadir texto, el comando sensatamente llamado “a”. Si movemos el cursor al final de la línea y escribimos “a”, el cursor se moverá hasta pasado el final de la línea y vi entrará en modo inserción. Esto nos permitirá añadir más texto:

The quick brown fox jumped over the lazy dog. It was cool.

Recuerda pulsar la tecla Esc para salir del modo inserción.

Como casi siempre querremos añadir texto al final de una línea, vi ofrece un atajo para moverte al final de la línea actual y comenzar a añadir texto. Es el comando “A”. Probémoslo y añadamos algunas líneas más a nuestro archivo.

Primero, movamos el cursor al principio de la línea usando el comando “0” (cero).

Ahora pulsamos “A” y añadimos las siguientes líneas de texto:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5

De nuevo, pulsamos la tecla Esc para salir del modo de inserción.

Como podemos ver, el comando “A” es más útil ya que mueve el cursor al final de la línea antes de entrar en el modo de inserción.

martes, 22 de diciembre de 2015

Edición básica

La mayoría de las ediciones consisten en unas pocas operaciones básicas como insertar texto, borrar texto y mover texto de sitio cortando y pegando. vi, por supuesto soporta, con su estilo propio todas estas operaciones. vi también proporciona una forma limitada de deshacer. Si pulsamos la tecla “u” mientras está en modo comando, vi deshará el último cambio que hayas hecho. Esto será práctico cuando probemos algunos de los comandos de edición básica.

lunes, 21 de diciembre de 2015

Moviendo el cursor

Mientras que está en el modo comando, vi ofrece un gran número de comandos de movimiento, algunos de los cuales comparte con less. Aquí hay una muestra:

Tabla 12-1: Teclas de movimiento de cursor
Tecla Mueve el cursor
l o Flecha derecha Un carácter a la derecha.
h o Flecha izquierda Un carácter a la izquierda.
j o Flecha abajo Abajo una línea.
k o Flecha arriba Arriba una línea.
0 (cero) Al principio de la linea actual.
^ Al primer espacio no en blanco en la linea actual.
$ Al final de la línea actual.
w Al principio de la siguiente palabra o signo de puntuación.
W Al principio de la siguiente palabra, ignorando signos de puntuación.
b Al principio de la anterior palabra o signo de puntuación.
B Al principio de la anterior palabra, ignorando signos de puntuación.
Ctrl-f o AvPág Abajo una página.
Ctrl-b o RePág Arriba una página.
númeroG A la línea número. Por ejemplo, 1G lo mueve a la primera linea del archivo.
G A la última línea del archivo.

¿Por qué se usan las teclas h, j, k y l para movimientos de cursor? Porque cuando vi fue originalmente escrito, no todos los terminales de vídeo tenían las teclas de las flechas, y los hábiles mecanógrafos podían usar teclas normales del teclado para mover el cursor sin tan siguiera tener que despegar los dedos del teclado.

Muchos comandos en vi pueden ir precedidos con un número, tal como el comando “G” listado antes. Precediendo un comando con un número, podemos especificar el número de veces que un comando va a ser ejecutado. Por ejemplo, el comando “5j” hace que vi mueva el cursor hacia abajo cinco líneas.

viernes, 18 de diciembre de 2015

Salvando nuestro trabajo

Para salvar el cambio que acabamos de hacer en nuestro archivo, sólo tenemos que introducir un comando ex estando en el modo comando. Esto se hace fácilmente pulsando la tecla “:”. Después de hacer esto, un carácter de dos puntos aparecerá en la parte de abajo de la pantalla:

:

Para guardar los cambios en nuestro archivo modificado, añadiremos una “w” después de los dos puntos y pulsaremos Enter:

:w

El archivo será guardado en el disco duro y tendremos un mensaje de confirmación en la parte inferior de la pantalla, como este:

"foo.txt" [New] 1L, 46C written

Consejo: Si lees la documentación de vim, notarás que (confusamente) el modo comando se llama modo normal y los comandos ex se llaman modo comando. Ten cuidado.

jueves, 17 de diciembre de 2015

Entrar en el modo de inserción

Para añadir texto a nuestro archivo, debemos entrar primero en el modo de inserción. Para hacerlo, pulsamos la tecla “i”. Tras esto, deberíamos ver lo siguiente en la parte inferior de la pantalla si vim está funcionando en su modo normal mejorado (esto no aparecerá en el modo compatible con vi):

-- INSERT --

Ahora podemos introducir texto. Prueba esto:

The quick brown fox jumped over the lazy dog.

Para salir del modo de inserción y volver al modo de comandos, pulsa la tecla Esc.

miércoles, 16 de diciembre de 2015

Modo de edición

Arranquemos vi de nuevo, esta vez pasándole el nombre de un archivo inexistente. Así es como creamos un nuevo archivo con vi:

[me@linuxbox ~]$ rm -f foo.txt
[me@linuxbox ~]$ vi foo.txt

Si todo va bien, deberíamos tener una pantalla como esta:

~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
"foo.txt" [New File]

Las tildes de ñ (“~”) indican que no existe texto en esa línea. Esto muestra que tenemos un archivo vacío. ¡No escribas nada todavía!

La segunda cosa más importante a aprender sobre vi (después de aprender a salir) es que vi es un editor modal. Cuando vi arranca, lo hace en modo comando. En este modo, casi cualquier tecla es un comando, así que si empezáramos a escribir, vi básicamente se volvería loco y se formaría un gran lío.

martes, 15 de diciembre de 2015

Modo de compatibilidad

En la pantalla de inicio del ejemplo anterior (tomada de Ubuntu 8.04), vemos el texto “Running in Vi compatible mode.”. Esto significa que vim funcionará en un modo que es parecido al funcionamiento normal de vi en lugar del funcionamiento mejorado de vim. Para los objetivos de este capítulo, querremos ejecutar vim con su funcionamiento mejorado.

Para hacerlo, tenemos algunas opciones:

Prueba ejecutar vim en lugar de vi.

Si funciona, considera añadir alias vi='vim' a tu archivo .bashrc.

Alternativamente, usa este comando para añadir una linea al archivo de configuración de vim:

echo “set nocp” >> ~/.vimrc

Las diferentes distribuciones de Linux empaquetan vim de formas distintas. Algunas distribuciones instalan, por defecto, una versión mínima de vim que sólo soporta un catálogo limitado de funciones. Según vayamos viendo las siguientes lecciones, puedes encontrarte con que faltan funciones. Si ese es el caso, instala la versión completa de vim.

lunes, 14 de diciembre de 2015

Arrancando y parando vi

Para arrancar vi, simplemente escribe lo siguiente:

[me@linuxbox ~]$ vi

Y aparecerá una pantalla como esta:

~
~
~                 VIM - Vi Improved
~
~                                             version 7.1.138
~               by Bram Moolenaar et al.
~      Vim is open source and freely distributable
~
~               Sponsor Vim development!
~     type  :help sponsor<Enter>    for information
~
~     type  :q<Enter>               to exit
~     type  :help<Enter> or <F1>    for on-line help
~     type  :help version7<Enter>   for version info
~
~            Running in Vi compatible mode
~     type  :set nocp<Enter>        for Vim defaults
~     type  :help cp-default<Enter> for info on this
~
~
~

Tal como hicimos con nano antes, la primera cosa que aprenderemos es cómo salir. Para salir, introducimos el siguiente comando (fíjate que los dos puntos forman parte del comando):

:q

El prompt del shell debería volver. Si, por alguna razón, vi no se cierra (normalmente porque hacemos un cambio a un archivo que no ha sido salvado todavía), podemos decirle a vi que eso es lo que queremos añadiendo un signo de exclamación al comando:

:q!

Consejo: Si te “pierdes” en vi, prueba a pulsar la tecla Esc dos veces para encontrar el camino otra vez.

viernes, 11 de diciembre de 2015

Un poco de historia

La primera versión de vi fue escrita en 1976 por Bill Joy, un estudiante de la Universidad de California en Berkley que más tarde se convirtió en co-fundador de Sun Microsystems. vi toma su nombre de la palabra “visual”, porque estaba pensado para permitir la edición en un terminal de vídeo con un cursor con movimiento. Anteriormente a los editores visuales, había editores de línea que trabajaban con una sola línea de texto a la vez. Para hacer un cambio, teníamos que decírle al editor de línea a que línea concreta tenía que ir y, luego, especificarle los cambios a realizar, como añadir o eliminar texto. Con la llegada de los terminales de vídeo (en lugar de los terminales basados en impresión como los teletipos) los editores visuales se hicieron posibles. vi en realidad incorpora un potente editor de líneas llamado ex, y podemos usar comandos para la edición de líneas mientras usamos vi.

La mayoría de las distribuciones no incluyen el auténtico vi; en su lugar, están equipados con un sustituto mejorado llamado vim (que es la abreviatura de “vi improved “ - “vi mejorado”) escrito por Bram Moolenaar. vim es una mejora sustancial sobre el vi tradicional de Unix y normalmente está simbólicamente enlazado (o con un alias) al nombre “vi” en los sistemas Linux. En los temas que siguen asumiremos que tenemos un programa llamado “vi” que en realidad es vim.

jueves, 10 de diciembre de 2015

Por qué deberíamos aprender vi

En esta moderna era de los editores gráficos y los editores de texto fáciles-de-usar como nano, ¿por qué deberíamos aprender vi? Hay tres buenas razones:
  • vi está siempre disponible. Puede ser un salvavidas si tenemos un sistema sin interfaz gráfica, como un servidor remoto o un sistema local con la configuración de las X estropeada. nano, aunque cada vez es más popular todavía no es universal. POSIX, un estándar de compatibilidad para sistemas Unix, requiere que vi esté presente.
  • vi es ligero y rápido. Para muchas tareas, es más fácil arrancar vi que encontrar el editor gráfico de texto en los menús y esperar que sus múltiples megabytes carguen. Además, vi está diseñado para teclear rápido. Como veremos, un usuario o usuaria con experiencia en vi nunca tiene que separar sus dedos del teclado mientras está editando.
  • No queremos que otros usuarios de Linux y Unix piensen que somos unos gallinas.

Ok, a lo mejor sólo son dos buenas razones.

miércoles, 9 de diciembre de 2015

Una ligera introducción a vi

Hay un viejo chiste sobre alguien que visita New York City y pregunta a un transeúnte cómo ir al sitio más famoso de música clásica:
Visitante: Perdone, ¿cómo puedo llegar al Carnegie Hall?
Transeúnte: ¡Practique, practique, practique!

Aprender la línea de comandos de Linux, como llegar a ser un pianista experto, no es algo que logramos en una tarde. Lleva años de práctica. En este capítulo, presentaremos el editor de texto vi (que se pronuncia “vi ai” en inglés), uno de los programas clave en la tradición Unix. vi es famoso por su compleja interfaz de usuario, pero cuando vemos a un maestro sentado en el teclado y comienza a “tocar”, seremos testigos de algo grandioso. No nos convertiremos en maestros en este capítulo, pero cuando lo terminemos, sabremos tocar “Palillos Chinos” en vi.

N. del T.: "Palillos Chinos" hace referencia a Chopsticks, un conocido solo de piano empleado como ejercicio en las clases de música.

martes, 8 de diciembre de 2015

Para saber más

  • La sección INVOCATION de la man page de bash cubre los archivos de arranque de bash al detalle.

lunes, 7 de diciembre de 2015

Resumiendo

En este capítulo hemos aprendido una habilidad esencial, editar archivos de configuración con un editor de texto. A partir de ahora, tal como vayas leyendo las man pages de los comandos, toma nota de las variables de entorno que soportan los comandos. Puede haber un par de joyas. En capítulos posteriores, aprenderemos las funciones de shell, una característica poderosa que podrás incluir en los archivos de arranque de bash, para añadir a tu arsenal de comandos personalizados.

viernes, 4 de diciembre de 2015

Activando nuestros cambios

Los cambios que hemos hecho a nuestro .bashrc no tendrán efecto hasta que cerremos nuestra sesión de terminal y arranquemos una nueva, ya que el archivo .bashrc sólo se lee al principio de la sesión. Sin embargo, podemos forzar que bash relea el .bashrc modificado con el siguiente comando:

[me@linuxbox ~]$ source .bashrc

Después de hacer esto, deberíamos poder ver el efecto de nuestros cambios. Prueba uno de los nuevos alias:

[me@linuxbox ~]$ ll

jueves, 3 de diciembre de 2015

¿Por qué son importantes los comentarios?

Siempre que modificas archivos de configuración es una buena idea añadir algunos comentarios para documentar tus cambios. Seguro que mañana recordarás lo que has cambiado, pero ¿qué pasará dentro de seis meses? Hazte un favor y añade algunos comentarios. Mientras estás en ello, no es mala idea guardar un registro de los cambios que haces.

Los scripts de shell y los archivos de arranque de bash usan el símbolo “#” para comenzar un comentario. Otros archivos de configuración pueden usar otros símbolos. La mayoría de los archivos de configuración tendrán comentarios. Úsalos como guía.

A menudo verás líneas en archivos de configuración que están comentadas para evitar que sean usadas por el programa afectado. Esto se hace para dar al lector recomendaciones para posibles configuraciones o ejemplos de la sintaxis de configuración correcta. Por ejemplo, el archivo .bashrc de Ubuntu 8.04 contiene estas líneas:

# some more ls aliases
#alias ll='ls -l'
#alias la='ls -A'
#alias l='ls -CF'

Las últimas tres líneas son definiciones válidas de alias que han sido comentadas. Si eliminas los símbolos “#” de delante de las tres líneas, una técnica llamada descomentar, activarás los alias. Inversamente, si añades un símbolo “#” al principio de una línea, puedes desactivar una linea de configuración mientras que conservas la información que contiene.

miércoles, 2 de diciembre de 2015

Usando un editor de texto

Todos los editores de texto pueden ser llamados desde la línea de comandos escribiendo el nombre del editor seguido del nombre del archivo que queremos editar. Si el archivo todavía no existe, el editor asume que queremos crear un nuevo archivo. Aquí tenemos un ejemplo usando gedit:

me@linuxbox ~]$ gedit some_file

Este comando arrancará el editor de texto gedit y cargará el archivo llamado “some_file”, si existe.

Todos los editores gráficos son bastante autoexplicativos, así que no los veremos aquí. En su lugar, nos concentraremos en nuestro primer editor de texto basado en texto, nano. Arranquemos nano y editemos el archivo .bashrc. Pero antes de hacerlo, practiquemos algo de “informática segura”. Cada vez que editamos un archivo de configuración importante, siempre es una buena idea crear primero una copia de seguridad del archivo. Esto nos protege en caso de que estropeemos el archivo mientras lo editamos. Para crear una copia de seguridad del archivo .bashrc, haz esto:

[me@linuxbox ~]$ cp .bashrc .bashrc.bak

No importa cómo llames al archivo de copia de seguridad, sólo escoge un nombre comprensible. Las extensiones “.bak”, “.sav”, “.old” y “.orig” son las formas más populares de indicar que es un archivo de copia de seguridad. Ah, y recuerda que cp sobrescribirá los archivos existentes silenciosamente.

Ahora que tenemos un archivo de copia de seguridad, arrancaremos el editor:

[me@linuxbox ~]$ nano .bashrc

Una vez que nano arranca, tendremos una pantalla como esta:

    GNU nano 2.0.3         File: .bashrc

# .bashrc


# Source global definitions

if [ -f /etc/bashrc ]; then
    . /etc/bashrc
fi

# User specific aliases and functions










                     [ Read 8 lines ]
^G Get Help^O WriteOut^R Read Fil^Y Prev Pag^K Cut Text^C Cur Pos
^X Exit    ^J Justify ^W Where Is^V Next Pag^U UnCut Te^T To Spell

Nota: si tu sistema no tiene nano instalado, puedes usar el editor gráfico en su lugar.

La pantalla consiste en un encabezado en la parte superior, el texto del archivo que estamos editando en el centro y un menú de comandos en la parte inferior. Como nano fue diseñado para reemplazar el editor de texto disponible en un cliente de correo, es muy escaso en opciones de edición.

El primer comando que deberías aprender en cualquier editor de texto es cómo salir del programa. En el caso de nano, pulsas Ctrl-x para salir. Esto viene indicado en el menú en la parte inferior de la pantalla. La notación “^X” significa Ctrl-x. Esta es una notación común para los caracteres de control usados por muchos programas.

El segundo comando que necesitamos conocer es cómo salvar nuestro trabajo. Con nano es Ctrl-o. Con este conocimiento en nuestro haber estamos preparados para hacer algo de edición. Usando la tecla de la flecha hacia abajo y/o la tecla AvPág, mueve el cursor al final del archivo, luego añade las siguientes líneas al archivo .bashrc:

umask 0002
export HISTCONTROL=ignoredups
export HISTSIZE=1000
alias l.='ls -d .* --color=auto'
alias ll='ls -l --color=auto'

Nota: Tu distribución podría incluir ya alguna de ellas, pero el duplicarlas no hace daño a nadie.

Aquí tenemos el significado de lo que hemos añadido:

Tabla 11-4: Lineas añadidas a nuestro .bashrc
Línea Significado
umask 0002 Establece el umask para resolver el problema con los directorios compartidos que vimos en el Capítulo 9.
export HISTCONTROL=ignoredups Hace que la función de grabación del historial del shell ignore un comando si el mismo comando se acaba de grabar.
export HISTSIZE=1000 Aumenta el tamaño del historial de comandos, del valor predefinido de 500 lineas, a 1000 lineas.
alias l.='ls -d .* --color=auto' Crea un nuevo comando llamado “l.” que muestra todos las entradas de directorio que empiezan con un punto.
alias ll='ls -l --color=auto' Crea un nuevo comando llamado “ll” que muestra un listado de directorios en formato largo.

Como podemos ver, muchas de nuestras líneas añadidas no son intuitivas ni obvias, así que sería una buena idea añadir comentarios a nuestro archivo .bashrc para ayudar a explicar las cosas a los humanos.

Usando el editor, cambiamos nuestras líneas añadidas para que quede así:

# Change umask to make directory sharing easier
umask 0002

# Ignore duplicates in command history and increase
# history size to 1000 lines
export HISTCONTROL=ignoredups
export HISTSIZE=1000

# Add some helpful aliases
alias l.='ls -d .* --color=auto'
alias ll='ls -l –-color=auto'

¡Ah, mucho mejor! Con nuestros cambios completados, pulsa Ctrl-o para guardar nuestro archivo .bashrc modificado, y Ctrl-x para salir de nano.

martes, 1 de diciembre de 2015

Editores de texto

Para editar (es decir, modificar) los archivos de arranque de shell, así como la mayoría de los otros archivos de configuración del sistema, usamos un programa llamado editor de texto. Un editor de texto es un programa que es, de algún modo, como un procesador de texto en el que podemos editar las palabras que hay en la pantalla con un movimiento del cursor. Difiere de un procesador de texto en que sólo soporta texto plano, y a menudo contiene funciones diseñadas para escribir programas. Los editores de texto son la herramienta central usada por los desarrolladores de software para escribir código, y por los administradores de sistema para manejar los archivos de configuración que controlan el sistema.

Hay muchos editores de textos diferentes disponibles para Linux; tu sistema probablemente tenga varios instalados. ¿Por qué hay tantos diferentes? Probablemente porque a los programadores les gusta escribirlos, y como los programadores los usan intensamente, escriben editores para expresar sus propios deseos sobre cómo deberían funcionar.

Los editores de texto se clasifican en dos categorías básicas: gráficos y basados en texto. GNOME y KDE incluyen algunos editores gráficos populares. GNOME cuenta con un editor llamado gedit, que generalmente se llama “Editor de Texto” en el menú de GNOME. KDE normalmente cuenta con tres que son (en orden de complejidad creciente) kedit, kwrite y kate.

Hay muchos editores basados en texto. Los más populares que encontrarás son nano, vi, y emacs. El editor nano es un editor simple y fácil de usar diseñado como un sustituto del editor pico suministrado con la suite de email PINE. El editor vi (en la mayoría de los sistemas Linux sustituido por un programa llamado vim, que es la abreviatura de “Vi Improved” - “Vi mejorado”) es el editor tradicional de los sistemas tipo Unix. Será el tema de nuestro próximo capítulo. El editor emacs fue escrito originalmente por Richard Stallman. Es un entorno de programación gigantesco, multiuso y multitarea. Aunque está fácilmente disponible, rara vez viene instalado en los sistemas Linux por defecto.

lunes, 30 de noviembre de 2015

¿Qúe archivos podríamos modificar?

Como regla general, para añadir directorios a tu PATH, o definir variables de entorno adicionales, coloca dichos cambios en .bash_profile (o equivalente, según tu distribución. Por ejemplo, Ubuntu usa .profile.) Para todo lo demás, coloca los cambios en .bashrc. A menos que seas el administrador del sistema y necesites cambiar los predefinidos para todos los usuarios del sistema, reduce tus modificaciones a los archivos de tu directorio home. En realidad es posible cambiar los archivos en /etc, como el archivo profile, y en muchos casos sería sensato hacerlo, pero por ahora, juguemos con seguridad.

viernes, 27 de noviembre de 2015

Modificando el entorno

Como ya sabemos dónde están los archivos de arranque y qué contienen, podemos modificarlos para personalizar nuestro entorno.

miércoles, 25 de noviembre de 2015

¿Qué hay en un archivo de arranque?

Si miramos dentro de un archivo .bash_profile típico (tomado de un sistema CentOS 4), vemos algo así:

# .bash_profile

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

# User specific environment and startup programs

PATH=$PATH:$HOME/bin
export PATH

Las líneas que empiezan con un “#” son comentarios y no son leídas por el shell. Son para que sean legibles por personas. La primera cosa interesante ocurre en la cuarta línea, con el siguiente código:

if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

Esto se llama un comando if compuesto, que veremos más en profundidad cuando lleguemos al scripting de shell en la Parte 4, pero por ahora lo traduciremos:

Si el archivo "~/.bashrc" existe, entonces
    lee el archivo "~/.bashrc".

Podemos ver que este fragmento de código es la forma en que un shell con login toma los contenidos de .bashrc. Lo siguiente en nuestro archivo de arranque tiene que ver con la variable PATH.

¿Te has preguntado alguna vez, cómo sabe el shell dónde encontrar los comandos cuando los introducimos en la línea de comandos? Por ejemplo, cuando introducimos ls, el shell no busca en todo el ordenador para encontrar /bin/ls (la ruta completa del comando ls), en su lugar, busca en una lista de directorios que están contenidos en la variable PATH.

La variable PATH a menudo (pero no siempre, depende de la distribución) es establecida por el archivo de arranque /etc/profile con este código:

PATH=$PATH:$HOME/bin

PATH se modifica para añadir el directorio $HOME/bin al final de la lista. Esto es un ejemplo de expansión con parámetros, como vimos en el Capítulo 7. Para demostrar como funciona, prueba lo siguiente:

[me@linuxbox ~]$ foo="This is some "
[me@linuxbox ~]$ echo $foo
This is some
[me@linuxbox ~]$ foo=$foo"text."
[me@linuxbox ~]$ echo $foo
This is some text.

Usando esta técnica, podemos añadir texto al final de los contenidos de una variable.

Añadiendo la cadena $HOME/bin al final del contenido de la variable PATH, el directorio $HOME/bin se añade a la lista de directorios a buscar cuando se introduce un comando. Esto significa que cuando queremos crear un directorio dentro de nuestro directorio home para almacenar nuestros programas privados, el shell está preparado para contenerlos. Todo lo que tenemos que hacer es llamarlo bin, y estamos listos para empezar.

Nota: Muchas distribuciones proveen esta configuración de PATH por defecto. Algunas distribuciones basadas en Debian, como Ubuntu, buscan la existencia del directorio ~/bin en el login, y dinámicamente lo añaden a la variable PATH si encuentran el directorio.

Finalmente, tenemos:

export PATH

El comando export le dice al shell que haga que los contenidos de PATH estén disponibles para los procesos hijos de este shell.

lunes, 23 de noviembre de 2015

¿Cómo se establece el entorno?

Cuando nos identificamos en el sistema, el programa bash arranca, y lee una serie de scripts de configuración llamados archivos de arranque (startup files), que definen el entorno por defecto compartido para todos los usuarios. A continuación se leen más archivos de arranque en tu directorio home que definen tu entorno personal. La secuencia exacta depende del tipo de sesión de shell que se inicie. Hay dos tipos: sesión de shell con login y sesión de shell sin login.

Una sesión de shell con login es aquella en la que nos preguntan nuestro nombre de usuario y contraseña; por ejemplo, cuando arrancamos una sesión de consola virtual. Un sesión de shell sin login es la que típicamente se da cuando arrancamos una sesión de terminal en la GUI.

Los shell con login leen uno o más archivos de arranque como se muestra en la Tabla 11-2:

Tabla 11-2: Archivos de arranque para sesiones de shell con login
Archivo Contenidos
/etc/profile Un script de configuración global que se aplica a todos los usuarios.
~/.bash_profile Un archivo de arranque personal del usuario. Puede utilizarse para extender o anular configuraciones del script de configuración global.
~/.bash_login Si ~/.bash_profile no se encuentra, bash intenta leer este script.
~/.profile Si no se encuentran ni ~/.bash_profile ni ~/.bash_login, bash intenta leer este archivo. Este es el que viene por defecto en las distribuciones basadas en Debian, como Ubuntu.

Las sesiones de shell sin login leen los siguientes archivos de arranque:

Tabla 11-3: Archivos de arranque para sesiones de shell sin login
Archivo Contenidos
/etc/bash.bashrc Un script de configuración global que se aplica a todos los usuarios.
~/.bashrc Un archivo de arranque personal del usuario. Puede usarse para extender o anular las configuraciones del script de configuración global.

Además de leer los anteriores archivos de arranque, los shells sin login también heredan el entorno de sus procesos padre, normalmente un shell con login.

Echa un vistazo a tu sistema y mira cuales de estos archivos de arranque tienes. Recuerda, como la mayoría de los archivos listados anteriormente empiezan con un punto (que significa que están ocultos), necesitarás usar la opción “-a” cuando uses ls.

El archivo ~/.bashrc es probablemente el archivo de arranque más importante desde el punto de vista de un usuario normal, ya que casi siempre se lee. Los shell sin login lo leen por defecto y la mayoría de archivos de arranque para los shell con login se escriben de forma que también lean el archivo ~/.bashrc.

viernes, 20 de noviembre de 2015

Algunas variables interesantes

El entorno contiene bastantes variables, sin embargo tu entorno puede diferir del presentado aquí, verás más o menos las siguientes variables en tu entorno:

Tabla 11-1: Variables de entorno
Variable Contenidos
DISPLAY El nombre de tu pantalla si estás corriendo un entorno gráfico. Normalmente es “:0”, que significa la primera pantalla generada por el servidor X.
EDITOR El nombre del programa que se usa para editar texto.
SHELL El nombre de tu programa de shell
HOME La ruta de tu directorio home.
LANG Define la configuración de caracteres y la secuencia de ordenado de tu idioma.
OLD_PWD El anterior directorio de trabajo.
PAGER El nombre del programa que se usa para paginar la salida. A menudo está establecido en /usr/bin/less.
PATH Una lista de directorios, separados entre sí por dos puntos ":", en la que se busca cuando introduces el nombre de un programa ejecutable.
PS1 Prompt String 1. Define el contenido de tu prompt de shell. Como veremos más tarde, puede ser ampliamente personalizado.
PWD El directorio de trabajo actual.
TERM El nombre de tu tipo de terminal. Los sistemas tipo Unix soportan muchos protocolos de terminal; esta variable establece el protocolo que se va a usar con tu emulador de terminal.
TZ Especifica tu zona horaria. La mayoría de los sistemas tipo Unix mantienen un reloj interno en el ordenador en Coordinated Universal Time (UTC) y luego muestran la hora local aplicando un desfase especificado por esta variable.
USER Tu nombre de usuario.

No te preocupes si algunas de estas variables faltan. Varían según la distribución.

miércoles, 18 de noviembre de 2015

Examinando el entorno

Para ver qué hay almacenado en el entorno, podemos usar el comando integrado en bash set o el programa printenv. El comando set nos mostrará tanto las variables del shell como las del entorno, mientras que printenv sólo mostrará estas últimas. Como nuestra lista de contenidos del entorno será muy larga, es mejor canalizar la salida de cualquiera de los comandos a less:

[me@linuxbox ~]$ printenv | less

Hacíendolo, deberíamos obtener algo parecido a esto:

KDE_MULTIHEAD=false
SSH_AGENT_PID=6666
HOSTNAME=linuxbox
GPG_AGENT_INFO=/tmp/gpg-PdOt7g/S.gpg-agent:6689:1
SHELL=/bin/bash
TERM=xtermXDG_MENU_PREFIX=kde-
HISTSIZE=1000
XDG_SESSION_COOKIE=6d7b05c65846c3eaf3101b0046bd2b00-
1208521990.996705-1177056199
GTK2_RC_FILES=/etc/gtk-2.0/gtkrc:/home/me/.gtkrc-
2.0:/home/me/.kde/share/config/gtkrc-2.0
GTK_RC_FILES=/etc/gtk/gtkrc:/home/me/.gtkrc:/home/me/.kde/share/config/gtkrc
GS_LIB=/home/me/.fonts
WINDOWID=29360136
QTDIR=/usr/lib/qt-3.3
QTINC=/usr/lib/qt-3.3/include
KDE_FULL_SESSION=true
USER=me
LS_COLORS=no=00:fi=00:di=00;34:ln=00;36:pi=40;33:so=00;35:bd=40;33;01:cd=40;33;01:or=01;05;37;41:mi=01;05;37;41:ex=00;32:*.cmd=00;32:*.exe:

Lo que vemos es una lista de las variables de entorno y sus valores. Por ejemplo, vemos una variable llamada USER, que contiene el valor “me”. El comando printenv puede listar también el valor de una variable específica:

[me@linuxbox ~]$ printenv USER
me

El comando set, cuando lo usamos sin opciones o argumentos, mostrará tanto las variables del shell como las del entorno, así como cualquier función definida del shell. Al contrario de printenv, su salida está cortésmente ordenada alfabéticamente:

[me@linuxbox ~]$ set | less

También es posible ver el contenido de una variable usando el comando echo, así:

[me@linuxbox ~]$ echo $HOME
/home/me

Un elemento del entorno que ni set ni printenv muestran son los alias. Para verlos, introduce el comando alias sin argumentos:

[me@linuxbox ~]$ alias
alias l.='ls -d .* --color=tty'
alias ll='ls -l --color=tty'
alias ls='ls --color=tty'
alias vi='vim'
alias which='alias | /usr/bin/which --tty-only --read-alias --show-dot --show-tilde'

lunes, 16 de noviembre de 2015

¿Qué se almacena en el entorno?

El shell almacena dos tipos básicos de datos en el entorno, sin embargo, con bash, los dos tipos son casi indistinguibles. Hay variables de entorno y variables de shell. Las variables de shell son bits de datos puestos allí por bash, y las variables de entorno son básicamente todo lo demás. Además de las variables, el shell también almacena algunos datos programáticos, llamados alias y funciones de shell. Vimos los alias en el Capítulo 5, y las funciones de shell (que están relacionadas con los scripts de shell) las veremos en la Parte 4.

viernes, 13 de noviembre de 2015

El entorno

Como vimos antes, el shell mantiene una cantidad de información durante nuestra sesión de shell llamada el entorno. Los datos almacenados en el entorno los usan los programas para determinar cosas acerca de nuestra configuración. Si bien la mayoría de programas usan archivos de configuración para almacenar las configuraciones del programa, algunos programas también buscan valores almacenados en el entorno para ajustar su comportamiento. Sabiendo esto, podemos usar el entorno para personalizar nuestra experiencia con el shell.

En este capítulo, trabajaremos con los siguientes comandos:
  • printenv – Imprime parte o todo el entorno
  • set – Establece opciones del shell
  • export – Exporta el entorno a los programas que se ejecuten a continuación
  • alias – Crea un alias para un comando

miércoles, 11 de noviembre de 2015

Resumiendo

Los sistemas más modernos proporcionan un mecanismo para gestionar múltiples procesos. Linux provee un rico catálogo de herramientas para este propósito. Dado que Linux es el sistema operativo de servidores más expandido en el mundo, esto tiene mucho sentido. Sin embargo, al contrario que otros sistemas, Linux se basa principalmente en herramientas de línea de comandos para la gestión de procesos. Aunque hay herramientas gráficas para procesos en Linux, las herramientas de línea comandos son ampliamente preferidas por su velocidad y ligereza. Aunque las herramientas de la GUI son más bonitas, a menudo crean una gran carga en el sistema, con lo que estropean su propósito.

lunes, 9 de noviembre de 2015

Más comandos relacionados con procesos

Cómo monitorizar procesos es una tarea importante para la administración de sistemas, hay muchos comandos para ello. Aquí tenemos algunos para jugar con ellos:

Tabla 10-6: Otros comandos relacionados con procesos
Comando Descripción
pstree Muestra una lista de procesos dispuestos en una estructura de árbol mostrando las relaciones padre/hijo entre los procesos.
vmstat Muestra una instantánea de los recursos de sistema usados, incluyendo memoria, intercambio (swap) y la E/S del disco. Para una visualización continua, añade al comando un periodo de tiempo (en segundos) para las actualizaciones. Por ejemplo: vmstat 5. Finaliza la salida con Ctrl-c.
xload Un programa gráfico que traza un gráfico mostrando la carga del sistema a lo largo del tiempo.
tload Igual que el programa xload, pero dibuja el gráfico en el terminal. Finaliza la salida con Ctrl-c.

viernes, 6 de noviembre de 2015

Enviando señales a múltiples procesos con killall

También es posible enviar señales a múltiples procesos eligiendo un programa específico o un nombre de usuario usando el comando killall. Aquí tenemos la sintaxis:

killall [-u user] [-signal] name...

Para demostrarlo, iniciaremos un par de instancias del programa xlogo y las finalizaremos:

[me@linuxbox ~]$ xlogo &
[1] 18801
[me@linuxbox ~]$ xlogo &
[2] 18802
[me@linuxbox ~]$ killall xlogo
[1]-  Terminated              xlogo
[2]+  Terminated              xlogo

Recuerda, como con kill, debes tener privilegios de superusuario para enviar señales a procesos que no te pertenecen.

miércoles, 4 de noviembre de 2015

Enviando señales a un proceso con kill

El comando kill se usa para enviar señales a programas. Su sintaxis más común es así:

kill [-signal] PID...

Si no se especifican señales en la línea de comandos, la señal TERM (Terminar) se envía por defecto. El comando kill se usa la mayoría de las veces para enviar las siguientes señales:

Tabla 10-4: Señales comunes
Número Nombre Significado
1 HUP Colgar. Es un vestigio de los buenos y viejos tiempos cuando los terminales estaban conectados a ordenadores remotos mediante líneas telefónicas y modems. La señal se usa para indicar a los programas que el terminal de control ha “colgado”. El efecto de esta señal puede demostrarse cerrando una sesión de terminal. El programa en primer plano, que está corriendo en el terminal, recibirá una señal y terminará.

Esta señal también se usa con muchos programas demonio para provocar una reinicialización. Esto significa que cuando se le envía esta señal a un demonio, se reiniciará y releerá su archivo de configuración. El servidor web Apache es un ejemplo de demonio que usa la señal HUP de esta forma.
2 INT Interrupción. Realiza la misma función que las teclas Ctrl-c enviadas desde el terminal. Normalmente termina un programa.
9 KILL Mata. Esta señal es especial. Mientras que los programas pueden elegir manejar las señales que les son enviadas de diferentes formas, incluso ignorarlas todas, la señal KILL realmente nunca se envía al programa objetivo. En su lugar, el kernel inmediatamente termina el proceso. Cuando un proceso es finalizado de esta forma, no se le da la oportunidad de “limpiar” o guardar su trabajo. Por esta razón, la señal KILL sólo debería ser utilizada como último recurso cuando otras señales de finalización fallan.
15 TERM Terminar. Esta es la señal por defecto enviada por el comando kill. Si un programa aún está lo suficientemente “vivo” como para recibir señales, se terminará.
18 CONT Continuar. Esta restaurará un proceso después de una señal STOP.
19 STOP Parar. Esta señal causa la pausa de un proceso sin terminarlo. Al igual que la señal KILL, no se envía al proceso objetivo, y por lo tanto no puede ser ignorada.

Probemos el comando kill:

[me@linuxbox ~]$ xlogo &
[1] 13546
[me@linuxbox ~]$ kill -1 13546
[1]+  Hangup                  xlogo

En este ejemplo, arrancamos el programa xlogo en segundo plano y luego le enviamos una señal HUP con kill. El programa xlogo termina y el shell indica que el proceso en segundo plano ha recibido una señal de cuelgue. Necesitarás pulsar la tecla intro un par de veces antes de ver el mensaje. Fíjate que las señales pueden ser especificadas con número o con nombre, incluyendo el nombre precedido de las letras “SIG”:

[me@linuxbox ~]$ xlogo &
[1] 13601
[me@linuxbox ~]$ kill -INT 13601
[1]+  Interrupt               xlogo
[me@linuxbox ~]$ xlogo &
[1] 13608
[me@linuxbox ~]$ kill -SIGINT 13608
[1]+  Interrupt               xlogo

Repite el ejemplo anterior y prueba las otras señales. Recuerda, también puedes usar jobspecs en lugar de PIDs.

Los procesos, como los archivos, tienen propietarios, y debes ser el propietario de un proceso (o el superusuario) para enviarle señales con kill.

Además de la lista de señales anterior, usadas generalmente con kill, hay otras señales usadas frecuentemente por el sistema. Aquí tenemos una lista de otras señales comunes:

Tabla 10-5: Otras señales comunes
Número Nombre Significado
3 QUIT Abandonar.
11 SEGV Violación de segmentación (Segmentation Violation). Esta señal se envía si un programa hace un uso ilegal de la memoria, es decir, trata de escribir en un sitio en el que no está autorizado.
20 TSTP Stop de terminal (Terminal Stop). Esta es la señal enviada por el terminal cuando se pulsa Ctrl-z. Al contrario que la señal STOP, el programa recibe la señal TSTP, pero puede optar por ignorarla.
28 WINCH Cambio de ventana (Window Change). Es una señal enviada por el sistema cuando una ventana cambia de tamaño. Algunos programas, como top y less responden a esta señal redibujándose a sí mismos para ajustarse a las nuevas dimensiones de la ventana.

Para los curiosos, se puede ver una lista completa de las señales con el siguiente comando:

[me@linuxbox ~]$ kill -l