Eternal Prisoner

Tal y como reza el titulo , eso es terminator . Una aplicación en la que podremos abrir una venta con una terminal , y desde ahí , particionar esta en todas las miniterminales que necesitemos . Podemos partir la pantalla en horizontal , en vertical , abrir terminales como pestañas , hacer zoom en una terminal en concreto , etc . Aquí sí que pagará más una imagen que mil palabras , así que ahí va . ( Clicka en la imagen para agrandar )

También tenemos atajos del teclado para esta aplicación cortesía de Linux para todos .

Autor: Javier EDuarte para Linux para todos

Les dejo algunos atajos para BASH
Ctrl+Shift+O
Dividir terminales horizontalmente
Ctrl+Shift+E
Dividir terminales verticalmente

Ctrl+Shift+Right
Mover dragbar principal a la Derecha

Ctrl+Shift+Left
Mover dragbar principal a la Izquierda

Ctrl+Shift+Up
Mover dragbar principal arriba

Ctrl+Shift+Down
Mover dragbar principal abajo

Ctrl+Shift+S
Mostrar/Ocultar barra Scroll

Ctrl+Shift+F
Buscar con el scrollback de la terminal

Ctrl+Shift+N or Ctrl+Tab
Mover a la siguiente terminal dentro de la misma tab,usando Ctrl+PageDown moveremos a la siguiente tab. Si cycle_term_tab es False, no funcionará

Ctrl+Shift+P or Ctrl+Shift+Tab
Mover a la anterior terminal dentro de la misma tab,usando Ctrl+PageDown moveremos a la anterior tab. Si cycle_term_tab es False, no funcionará

Ctrl+Shift+C
Copiar lo seleccionado al portapapeles

Ctrl+Shift+V
Pegar texto del portapapeles

Ctrl+Shift+W
Cerrar la terminal actual

Ctrl+Shift+Q
Quitar Terminator

Ctrl+Shift+X
Mostrar solamente la terminal actual

Ctrl+Shift+Z
Ampliar la terminal actual

Ctrl+Shift+T
Abrir nueva tab.

Ctrl+Shift+Alt+T
Abrir nueva tab en nivel root, (si usamos extreme_tabs)

Ctrl+PageDown
Mover a la siguiente Tab

Ctrl+PageUp
Mover a la anterior Tab

Ctrl+Shift+PageDown
Intercambiar posición con la siguiente Tab

Ctrl+Shift+PageUp
Intercambiar posición con la anterior Tab

Ctrl+Shift+F
Open buffer search bar to find substrings in the scrollback buffer. Hit Escape to cancel.

Ctrl+Plus (+)
Aumentar tamaño de la fuente

Ctrl+Minus (-)
Disminuirtamaño de la fuente

Ctrl+Zero (0)
Restaurar tamaño original de la fuente
F11
Tab a pantalla completa

 

Cuando hay comandos que usas de forma cotidiana , siempre es aconsejable crear un alias si estos son muy extensos .

Por ejemplo , si queremos usar tupac para actualizar tanto los paquetes oficiales , como de aur , seria :

 

$ tupac -Syu –aur –devel

 

Esta claro que nadie se rompe la mano con esto , pero no seria por ejemplo , mas facil escribir up y que con eso actualice ? Pues aquí es donde entra en juego alias .

Vamos a crear uno para este caso especifico :

 

$ alias up="tupac -Syu –aur -devel"

 

Pero de esta forma no dura por siempre el alias , si queremos que así sea , debemos añadir esta linea en /home/tu_usuario/.basrc y listo , ya tenemos nuestro alias para usarlo cuando queramos

En un inicio , se tiene la idea de que la shell es un sitio inhospito y hostil , en donde se tiene que entrar , hacer lo que se tenga que hacer , y volver a la luz de nuestro escritorio .

Pero bueno , tampoco es asi , virtualmente , podemos hacer alli todo lo que podemos hacer en un escritorio , ya sea ver peliculas , mirar pdfs o fotos , escuchar musica , navegar por internet leyendo articulos y mirando imagenes , etc ( Aunque por desgracia no podremos disfrutar del flashplugin ) 

 

Pues bien , vamos camino a poder hacer algo así en nuestra arch :

 

 

 

 

Mplayer

 

 

Visor de imagenes

 

 

Links

 

Así no parece tan fiero el lobo como lo pintan , no ? Pues bien , si tu interes en esto persiste , vamos a instalar lo necesario .

Pero ….. primero buscaremos una buena resolución a nuestra shell para ver las coas nitidas y en condiciones , es sencillo , solo tenemos que editar el archivo /boot/grub/menu.lst , ahí veremos algo como esto :

 

#                FRAMEBUFFER RESOLUTION SETTINGS
#     +————————————————————————————-+
#             | 640×480       800×600      1024×768      1280×1024
#      —-+———————————————————————————
#      256 | 0×301=769  0×303=771  0×305=773   0×307=775
#      32K | 0×310=784  0×313=787  0×316=790   0×319=793
#      64K | 0×311=785  0×314=788  0×317=791   0×31A=794
#      16M| 0×312=786  0×315=789  0×318=792   0×31B=795
#     +————————————————————————————+
 

Que es , ni mas ni menos , que nuestra chuleta . Por mi parte elegí la de 1280×1024 con una profundidad de color de 16 millones . Por lo tanto me quedo cierta linea así ……. :

 

kernel /boot/vmlinuz26 root=/dev/sda3 ro vga=795

 

Bien fácil , añadir la coletilla vga=795 al fínal . Ahora ya se ve mas en condiciones , marchando una de driver y raton :

 

# pacman -S xf86-video-fbdev gpm

 

El primero es el driver gráfico , el segundo lo que necesitamos para tener ratón en la shell . Editamos rc.conf y añadimos gpm como demonio , y ahora lo lanzamos :

 

# /etc/rc.d/gpm

 

Perfecto , ahora empecemos a disfrutar viendo una buena peli con mplayer , como lo haremos ? Así :

 

$  mplayer -zoom -x 1290 -y 1020  On*\ Pi*c*\ 197\ \[Shichibukai\]\ \[x.264-AAC\].mp4

 

Que corresponde a la imagen primera , todo un lujazo . Pero vamos a ver una imagen que tenemos en el escritorio , vale ?  Antes hagamonos con un buen visor :

 

# pacman -S fbv

 

Y ahora ….

 

$ fbv tabla1.jpg

 

que corresponde a nuestra segunda imagen , va bien la cosa , no ? Vamos a visitar alguna pagina con links ……

 

$ links -driver fb www.google.es

 

Aún os parece que no se puede vivir tranquilamente en la shell ?

 

Pero bueno , no todo son flores y violas , estoy buscando un segundo visor que me permita ver pdf , de momento probé fbi , pero solo me enseña la primera pagina . Aunque el tanteo es mas que excelente , no os parece ? Un saludo  

 

Cuando queremos comprobar las diferencias entre dos archivos , lo podemos hacer de forma facil :

$ diff archivo1 archivo2

Y nos enseñara las diferencias entre los dos archivos , muy util cuando se actualiza un paquete , y queremos ver los cambios de la nueva version . Un saludete .

Hoy seré breve . Para cuando queramos irnos , pero a sabiendas que el ordenador se apagara una vez se acabe la descarga , o lo que sea menester . lo haremos con la ayuda del siguiente comando . Desde root escribimos :

$ sudo shutdown -h 15

Con el argumento -h , que hara que se apague la maquina , y dandole un periodo de tiempo , 15 minutos por ejemplo , ara que se apague en 15 minutos . De querer lo mismo pero reiniciando , cambiariamos -h por -r .

Si queremos reiniciar o apagar al momento , podemos usar now , y nos quedaria un reinicio inmediato , algo así :

$ sudo shutdown -r now

Bien , esto nos a servido para saber como funciona de forma basica el comando shutdown , venga un saludin .

Bien , hoy vamos a ver como aplicamos una guia de la wiki de Archlinux . Ya que puede parecer algo confusa , guiaremos el tutorial , que esta en este enlace .

Primero vamos a por offlineimap , el cual necesitaremos para descargar nuestro correo , esto sera tan sencillo como ya suponemos todos :

# pacman -S offlineimap

Bien , esto es algo que todos esperabamos , ahora vamos con lo que realmente puede ser lioso . Crearemos el archivo ~/.offlineimaprc y lo editaremos con nuestro editor preferido , en el ejemplo con nano :

$ touch ~/.offlineimaprc

$ nano ~/.offlineimaprc

Y añadimos lo siguiente , también marcare los cambios que haremos … :

|—————————————————————————————————————————————–|

[general]
# change to whatever you want:
accounts = myaccount  <----------------------- gMail mismo 

# Gives you a nice blinky output on the console so you know what's happening:
ui = Curses.Blinkenlights 

# If uncommented, this would show nothing at all. Great for cronjobs or background-processes:
# ui = Noninteractive.Quiet 

[Account myaccount]   <---------------------------- Cambiamos  myaccount por gMail
# Profile-Name for the local Mails for a given Account
localrepository = mylocal 

# Profile-Name for the remote Mails for a given Account
remoterepository = myremote 

# fetches your mails every 5 Minutes
autorefresh = 5 

[Repository mylocal]
# Way of storing Mails locally. Only Maildir is currently supported:
type = Maildir 

# Place where the synced Mails should be:
localfolders = ~/Mail <---------------- Podemos elegir otro directorio si queremos

[Repository myremote]
# Type of remote Mailbox. Only IMAP is supported right now:
type = IMAP 

# Where to connect:
remotehost = imap.gmail.com 

# Whether to use SSL or not:
ssl = yes 

# Would specify a port if uncommented. This way, it just tries to use a default-port:
# remoteport = 993 

# Specify login-name:
remoteuser = myremoteusername <----------------- tu correo@gmail.com

# Specify login-password (there are other/safer options for storing passwords for use by OfflineIMAP,
# see the OfflineIMAP manual. Make sure that ~/.offlineimaprc is readable only by you, if you
# specify your password here!):
remotepass = myremotepassword  <------------------------- tu password de gmail

|-------------------------------------------------------------------------------------------------|
.
Con lo que queda :
.
|-------------------------------------------------------------------------------------------------|
[general]
# change to whatever you want:
accounts = gMail

# Gives you a nice blinky output on the console so you know what's
happening:
ui = Curses.Blinkenlights

# If uncommented, this would show nothing at all. Great for cronjobs or
background-processes:
# ui = Noninteractive.Quiet

[Account gMail]
# Profile-Name for the local Mails for a given Account
localrepository = mylocal

# Profile-Name for the remote Mails for a given Account
remoterepository = myremote

# fetches your mails every 5 Minutes
autorefresh = 5

[Repository mylocal]
# Way of storing Mails locally. Only Maildir is currently supported:
type = Maildir

# Place where the synced Mails should be:
localfolders = ~/Mail

[Repository myremote]
# Type of remote Mailbox. Only IMAP is supported right now:
type = IMAP

# Where to connect:
remotehost = imap.gmail.com

# Whether to use SSL or not:
ssl = yes

# Would specify a port if uncommented. This way, it just tries to use a
# default-port:
# remoteport = 993

# Specify login-name:
remoteuser = xxxxx@gmail.com <----------- Mi mail

# Specify login-password (there are other/safer options for storing
# passwords for use by OfflineIMAP,
# see the OfflineIMAP manual. Make sure that ~/.offlineimaprc is
# readable only by you, if you
# specify your password here!):
remotepass = xxxxxxxx <---- Mi password de gMail

|-------------------------------------------------------------------------------------------------|
.
Si hemos dejado el directorio donde se almacenaran los mails que venia , crearemos dicho directorio
( Si no también pero con el nombre pertinente ) 

$ mkdir Mail 

Y acto seguido correremos offlineimap ...

$ offlineimap 

Hecho esto tendréis que ver algo así :

Ya tenemos lo mas importante , pero no todo , sigamos con ello . Ahora es turno de instalar mutt y configurarlo para maildir .

# pacman -S mutt

Creamos la carpeta .mutt y el archivo muttrc dentro de ella …….

$ mkdir .mutt

$ cd .mutt

$ nano muttrc

Ahora lo editamos tal y como indica la guia , de la siguiente forma ………. :

|—————————————————————————————————————————————–|

set mbox_type=Maildir
set folder=$HOME/Mail
set spoolfile=+/INBOX
set header_cache=~/.hcache

|-------------------------------------------------------------------------------------------------|

Sigamos para bingo , ya recibimos pero necesitamos enviar , no es asi ? Vamos a configurar el smtp .
Instalemos el paquete msmtp y configuremos :

# pacman -S msmtp
$ nano muttrc

Y añadimos ............ : 

|-------------------------------------------------------------------------------------------------|

set realname='Disgruntled Kangaroo' <-------------------- Lo cambiamos por lo que nos de la gana

set sendmail="/usr/bin/msmtp"

set edit_headers=yes
set folder=~/Mail <-------------------- Tendremos cuidado con las minusculas y mayusculas
set mbox=+mbox
set spoolfile=+INBOX <------------------------ Aquí también
set record=+sent
set postponed=+drafts
set mbox_type=Maildir

mailboxes +inbox

|-------------------------------------------------------------------------------------------------|
.
Con lo que queda :
.
|-------------------------------------------------------------------------------------------------|

set mbox_type=Maildir
set folder=$HOME/Mail
set spoolfile=+/INBOX
set header_cache=~/.hcache

set realname='Raist'

set sendmail="/usr/bin/msmtp"

set edit_headers=yes
set folder=~/Mail
set mbox=+mbox
set spoolfile=+INBOX
set record=+sent
set postponed=+drafts
set mbox_type=Maildir

mailboxes +inbox
|-------------------------------------------------------------------------------------------------|
Y listo , ahora lanzando mutt nos tiene que salir el correo , pero siempre antes de usar mutt ,
recordad de lanzar offlineimap para recibir correo .

Y esto luce asi : 



Aunque si os a surgido algún problema o veis que me he liado en algo , no dudéis a contactar
conmigo y miraremos de solucionarlo , espero que os sea útil y un saludo !

Estos dos comandos a la par de curiosos tambien tienen su utilidad , y para explicarlos , que mejor que con el ejemplo , no ? Pues vayamos a ello .

[Prueba@Prueba ~]$ whatis cd
cd [] (1) – paranoia 9.8 (Paranoia release III via libcdio) – an audio CD reading utility which includes extra data verification features
cd [] (1p) – change the working directory
cd [] (n) – Change working directory

Pues bien , tal y como dice la pagina man es :

whatis  busca  el  contenido de palabra_clave, en una base de datos que
contiene breves descripciones de  los  comandos,  mostrando  todas  las
descripciones  que  contienen  una  palabra idéntica ( una palabra com‐
pleta).

Interesante , verdad ? Recordemos que crearemos la base con makewhatis . Pues el otro comando no es menos interesante , y este es :

[juanma@Prey ~]$ whereis libungif
libungif: /usr/lib/libungif.so /usr/lib/libungif.a

Como veis , nos dice la ruta de cualquier codigo , binario o manual que indiquemos de un especifico archivo . A diferencia del whatis , a este ultimo le podemos pasar parametros para ser mas esplicitos , vereis esos parametros en su pagina man . No son la panacea de la terminal , pero a parte de curiosos son utiles , no creeis ? A demas , el saber no ocupa lugar , venga un saludo .

Muchas veces pasa que de repente , una aplicación que estamos usando se cuelga , pululando inútilmente por nuestro escritorio . Cosa que es bastante molesto , así que vamos a ver como matamos el proceso , con esto , conseguiremos que la aplicación se cierre .

Vamos a ver dos formas de encontrar el proceso :

Top

Mas adelante hablaremos de las virtudes de este comando de forma exclusiva , pero hoy nos centraremos en lo que estamos hablando :

$ top

Y nos saldrá algo así :

Aunque si queremos que nos resalte los diferentes estados de los procesos pulsaremos z

Bueno , daremos algunos datos , como vemos en top , nos dice , que hora es , desde cuando lleva encendido , cuantos usuarios hay conectados y el promedio de carga .

En la segunda , y mas interesante para este articulo , veremos las tareas totales , las que hay corriendo , las que estan durmiendo , parados y las zombis , estas ultimas son los procesos colgados .

En la tercera datos sobre el uso de CPU .

En la siguiente podremos ver la ram total , la usada , la libre , y los bufers .

En la quinta lo mismo pero con la swap .

Si localizamos un proceso zombi , que hay veces que lo detecta pero no lo muestra , nos fijamos en su PID , tras esto pulsamos k y veremos que debajo de los datos de swap nos sale : PID to kill : , pues nada , escribimos el PID del proceso e intro , proceso muerto , sencillo , verdad ? Por ultimo , para salir de top , pulsad la q . Mas info $ man top

Y si no nos sale en la lista de top ? Tranquilos , que tenemos una facil solucion :

$ ps aux | most

most si tenéis el paquete instalado ( Cosa muy recomendable , si no cuando lo pruebes ya me dirás ) , si no more o less , los cuales conocéis de este articulo , o de antes . Pues bien , exploramos todos los procesos que nos han salido , buscamos el concreto de la aplicación en cuestión , anotamos el PID , veréis también la Z de zombi , y ahora vamos a matarlo :

$ kill PID

También podemos curiosear el $ man kill para tener mas información sobre el comando , ser curioso en Gnu/Linux es mas que imprescindible , si queréis gozar de verdad de este sistema .

Ante alguna duda sobre esto u otra cosa ya sabéis , un comentario al canto , o en la pestaña contacta . Un saludo y hasta la próxima .

Vimos que con cat podíamos añadir lineas a un archivo , aunque tambien podemos crear uno , agregarle mas datos , o borrar e insertar nuevos datos . La forma es muy parecida a la de añadir simples lineas .

creando un archivo y escribiendo en el :

$ cat archivo_prueba

>Como veis

>sera facil añadir lineas al archivo

>de esta forma

Luego con control + d guardamos el archivo .

Y si , seguiriamos añadiendo lineas con $ cat >> archivo_prueba , y borrando el contenido y empezando de nuevo con $ cat > archivo_prueba .

more y less

Para manejarnos de una forma adecuada por la shell , y no tener que recurrir a un tip como este cuando leamos un archivo de texto grande , tenemos a more y less . Que hacen los comandos more y less ? Nos permiten paginar la salida por pantalla , de forma que podamos leerlo todo poco a poco y sin perdernos detalle . Cada uno a su forma , después ya hablaremos de most , el cual es similar . Vamos con los ejemplos que son mas esclarecedores , ya se sabe , vale mas una imagen que mil palabras :

$ cat /etc/X11/xorg.conf | more

Aquí veremos que nos empieza a salir el texto linea por linea , e iremos avanzando con la tecla intro para ir viendo con cada pulsación una nueva linea . Si no queremos llegar al final del archivo , saldremos con la tecla q . Vamos a ver algo mejor :

$ cat /etc/X11/xorg.conf | less

Ahora ya disponemos de muchas funciones , nos desplazamos con las flechas , no sale al probar de sobrepasar la ultima linea ( Sale con q también ) , podemos avanzar o retroceder mas rápido con Repág y Avpág y otras funciones que veréis en las paginas man ( $ man less , $ man more , etc ) . Y ahora lo mismo pero mas bonito , con información adicional , de linea y el tanto por cien del documento que fuimos leyendo , etc :

$ cat /etc/X11/xorg.conf | most

Que , como una manpage , verdad ? Y mas cómoda lectura , no es así ? Como ya sabéis , mas información en su man page . Por finalizad vamos con un :

Tip

Si queremos lanzar el ultimo comando que fue lanzado , sin tener que teclear este si fue muy largo , nos bastara con :

$ !!

También con la flecha hacia arriba nos saldría , pero no esta de mas saber algo mas , quien sabe si la función nos servirá en algún script que hagamos .

Próximamente mas

Vamos a usar de forma basica algunos comandos , que en un inicio pueden parecer poco practicos , pero que a medida que avanzamos van adquiriendo verdadera importancia , y de paso los conoceremos un poco .

touch : Con este simple comando crearemos un archivo para nuestras pruebas . Tan simplemente como por ejemplo :

$ touch prueba

Ya tenemos el archivo que vamos a usar para nuestras pruebas con los siguientes comandos . echo es un comando de salida , de uso sencillo , para hacer una prueba y comprender que hace haremos esto mismo .

echo :

$ echo estamos de pruebas !

estamos de pruebas !

Ahora le añadiremos algunas frases al archivo , con echo , sin tener que editarlo .

$ echo añado la primera linea > prueba

Esto añade la linea ” añado la primera linea” al archivo prueba , esto es sencillo , pero debemos ser cautos en una cosa . Como vemos , tras el comando echo , hemos escrito la frase a añadir , el símbolo > y por ultimo el nombre del archivo . En lo que se tiene que prestar suma atención , es en el símbolo > , que no solo añade una linea , si no que si en el archivo hubiesen mas datos , los borraría , como evitar esto ? añadiendo >> , así añade una linea mas a continuación respetando el resto , sed precavidos con esto . Vamos a añadir algunas lineas mas para poder jugar con los otros comandos .

$ echo añado la segunda >> prueba

$ echo añado la tercera >> prueba

$ añado la cuarta >> prueba

Ahora ya tenemos el archivo con varias lineas y listo para que podamos experimentar con el . Vamos a leerlo , para ello usaremos el comando cat.

cat :

$ cat prueba

añado la primera linea
añado la segunda
añado la tercera
añado la cuarta

cat tiene asociada la entrada del teclado y la salida en pantalla , y nos a mostrado el contenido del archivo prueba . Si el archivo es pequeño , no hay problema para que nos diga todo lo que contiene , pero vamos a filtrar el contenido , para que nos de solo lo que deseamos , y lo haremos con grep .

grep :

$ grep segunda prueba

añado la segunda

Sencillo , practico y efectivo . Al comando grep le hemos dado la palabra clave a buscar , ” segunda ” , y le hemos dicho el archivo , ” prueba ” , y el nos a filtrado las lineas que contienen esta palabra en ese archivo . Estos comandos se pueden usar con opciones y/o combinados , pero mejor quedarnos con el concepto y profundizar con ellos mas a delante .

Espero que os haya sido interesante , un saludo y hasta la proxima