Programaion Bash
Introducción
Linux, así como la mayoría de los UNIX, utilizan shell scripts para realizar una infinidad de tareas. Un shell script es un programa que se escribe con una sintaxis particular, en un archivo de texto plano, para que sea interpretado por un shell, en este caso /bin/bash.
Un shell script es básicamente un programa que llama a otros programas, con la posibilidad de hacer algun tipo de procesamiento propio (como control de flujo, operaciones matemáticas simples, etc).
Por lo tanto la forma de crear un shell script es hacer un archivo con nuestro ya querido vi:
vi holam
Luego lo llenamos con las instrucciones que deseamos. Por ejemplo:
#!/bin/bash echo "Hola mundo!" # Esto es por costumbre utilizado como ejemplo del primer programa. # Se dice que trae suerte!
Luego le damos permisos de ejecución a ese archivo:
chmod +x holam
Y de esta manera ya tendremos listo un shell script que se ejecuta de la siguiente forma:
./holam
Debemos destacar la primera linea de nuestro script bash:
#!/bin/bash
esta línea le indica al sistema que el script será interpretado por el programa que se encuentra a continuación de #!, en este caso, /bin/bash
Las últimas dos líneas son comentarios
# Esto es por costumbre utilizado como ejemplo del primer programa. # Se dice que trae suerte!
Los comentarios comienzan con # y se extienden hasta el final de la línea. Es muy útil ir comentando el código que uno escribe, para recordar qué realizan ciertas funciones o algoritmos, y otra persona pueda comprender el funcionamiento de nuestro script.
Variables
Las variables en un script BASH son simplemente identificadores, sin tipo. Para asignar un valor a una variable, se utiliza el operador =, por ejemplo:
[jose@xtech experto]$ MIVARIABLE=4
Por convención, los nombres de las variables se usan en mayúsculas, aunque no es obligatorio.
Para usar el contenido de la variable, dentro de un script, se usa el operador $. Por ejemplo:
[jose@xtech experto]$ echo $MIVARIABLE 4 [jose@xtech experto]$
Para utilizar el contenido de una variable, seguida de un texto, debemos usar las llaves {}
Consideremos este ejemplo:
ARCHIVO="/tmp/ej" mv $ARCHIVO $ARCHIVO-bak
En este caso, bash interpretaría a $ARCHIVO y $ARCHIVO-bak como dos variables distintas, para evitar esto debemos reescribirlo de esta manera:
ARCHIVO="/tmp/ej"
mv $ARCHIVO ${ARCHIVO}-bak
Comillas
En el shell, el espacio, o el tab, son separadores. Es decir, que cuando al shell le indicamos
ls -l hola que tal
Lo interpreta como que le pedimos que nos de información sobre tres archivos, llamados: hola, que, y tal.
Si en realidad, lo que queríamos, era información sobre un archivo llamado "hola que tal", entonces hay varias maneras de indicarle al shell que los espacios entre esas palabras no deben ser separadores.
Escape ( \ )
Hay un caracter de escape, que indica al shell que el siguiente carácter no es especial. Y es la barra invertida. Por lo tanto, podríamos obtener la información del archivo "hola que tal" de la siguiente forma:
ls -l hola\ que\ tal
Los espacios no son especiales, no son separadores, y "hola que tal" es una sola palabra.
Algunos caracteres especiales más:
\ @ ! | < > [ ] { } ( ) ? * $ ' ^ ` " # & ;
Por lo tanto, si queremos incluir la \ en alguna parte, entonces debemos ponerla 2 veces (\\), la primera para decirle a BASH que no tome como carácter especial lo que sigue y la segunda como ese carácter que queremos incluír. Esto es muy común en casos como:
cd algún\ directorio\ con\ espacios
Comillas dobles ( " " )
Las comillas dobles hacen que los espacios entre las comillas no sean especiales. Por lo tanto, podríamos haber utilizado:
ls -l "hola que tal"
Todos los otros carácteres siguen siendo especiales.
Comillas simples ( ' ' )
Las comillas simples logran que ningún caracter (salvo la comilla simple misma) sea especial. Por ejemplo, si quisieramos crear un archivo que se llame *@$&, lo debemos hacer rodeándolo de comillas simples:
touch '*@$&'
Si queremos poner una comilla simple, debemos "escaparla". Para crear un archivo llamado que'tal, deberíamos hacerlo así:
touch 'que\'tal'
Ya que si no lo hacemos, la segunda comilla "cierra" la primera!
Comilla invertida ( ` ` )
Las comillas invertidas son más raras. Deben rodear un comando. Ese comando será ejecutado, y lo que ese comando imprima reemplazará al contenido de las comillas invertidas. Tal vez lo más sencillo sea un ejemplo:
[jose@xtech experto]$ ls experto.aux experto.log experto.lyx experto.pdf experto.tex experto.dvi #experto.lyx# experto.lyx~ experto.ps experto.toc [jose@xtech experto]$ V=`ls` [jose@xtech experto]$ echo $V experto.aux experto.log experto.lyx experto.pdf experto.tex experto.dvi #experto.lyx# experto.lyx~ experto.ps experto.toc [jose@xtech experto]$
El uso más frecuente de las comillas invertidas es poder asignar el "resultado" de un comando a una variable.
Control de flujo
Esto refiere al cauce o flujo normal de los programas. No siempre hay un solo camino a seguir y estas proposiciones permiten que el programa realice distintas tareas, según las condiciones de las variables a interpretar.
"if"
El"if" es un proposición de control que verifica si es verdadera o falsa una condición.
Sintaxis:
if comando-condición then Comandos si la condición es verdadera else Comandos si la condición es falsa fi
Es importante que la ubicación de las lineas se mantenga, ya que las proposiciones if/then/else/fi se controlan línea por línea. La parte else es opcional. En caso de querer hacer todo el control en una sola línea, las proposiciones deberán estar separadas por un punto y coma (;).
Los comandos que estén debajo del then se ejecutarán si la condición dio verdadera. Esto quiere decir que el valor de retorno de la condición fue 0 (cero). En caso contrario se ejecutarán los comandos que le siguen al else, si es que se utilizó esta proposición.
En la condición se puede poner un comando, donde la ejecución del mismo (su valor de retorno) definirá qué comandos (de qué proposición) se ejecutarán.
Si se verifica una condición, se deberán utilizar los corchetes para mayor comprensión.
Ejemplos:
(utilizando comandos)
if ps ax | grep httpd | grep -v grep then echo "El web server está funcionando" else echo "El web server NO esta funcionando" fi
(utilizando condiciones)
if [ -w /etc/passwd ] then echo "Tengo permisos de escritura en el archivo /etc/passwd" else echo "NO tengo permisos de escritura en el archivo /etc/passwd" fi
Puede suceder que tengamos que testear mas de una condicion, para esto, podemos utilizar la siguiente estructura:
if condición1 then Comando1 Comando2 elif condición2 then Comando1 Comando2 else Comando-por-defecto #Ninguna de las condiciones anteriores es verdadera fi
Esta es una manera de abreviar varias estructuras if - then - else - if en una sola, pudiendo utilizarse más de dos condiciones.
La estructura de control if, es muy utilizada con
test, que no es más que una operación de comparación, en las condiciones que se requieran."case"
El "case" es una proposición que puede analizar y validar varios casos (opciones) del valor de una variable.
Sintaxis
case variable in patrón | patrón) Comando; Comando; Comando;; patrón | patrón) Comando; Comando; Comando;; *)
Comandos si ningún otro valor fue igualado;;
esac
El case es raramente usado, pero es muy eficiente en algunos casos.
Ejemplos:
case $mes in ene*|Ene*) echo "Mes de Enero";; feb*|Feb*) echo "Mes de Febrero";; mar*|Mar*) echo "Mes de Marzo";; *) echo "Algún otro mes!";; esac
Ciclos
Los ciclos contienen secciones del programa que se repetirán una determinada cantidad de veces o hasta que alguna condición cambie.
for
El for debe ser el ciclo más utilizado, es muy práctico cuando se trabaja con shell scripts.
A diferencia de los lenguajes de programación más comunes, un ciclo for dentro de un shell script realiza una acción dada sobre cada uno de los elementos de una lista, y no sobre una variable que se va incrementando en cada ciclo.
La variable utilizada en el for (en este caso $i) es reemplazada por cada una de las palabras de la lista, en cada ciclo del for.
Sintaxis:
for i in lista de palabras do cuerpo del ciclo, $i tiene el valor de elementos sucesivos de la lista done
Ejemplos:
for i in `ls -1 /tmp` do echo $i rm -i $i done
En este ciclo, el comando ls -1 /tmp, generará una lista de todos los archivos que existen en el directorio /tmp. Dentro del cuerpo del ciclo imprimimos el contenido de la variable y luego preguntamos si se desea borrar ese archivo (opción -i del comando rm).
while
Este ciclo utiliza la condición de terminación de un comando (valor de retorno) para controlar la ejecución de los comando dentro del ciclo. Termina la ejecución del ciclo, cuando el comando devuelve falso (algo diferente a 0).
Sintaxis:
while comando do cuerpo del ciclo ejecutado a condición de que el comando devuelva verdadero done
Ejemplos:
while sleep 60 do who | grep daniel done
En este ejemplo, cada 60 segundos (definidos por el comando sleep 60), verificará si el usuario daniel ha ingresado al equipo. En caso de que lo haya hecho, el listado del who saldrá por pantalla (cada 60 segundos).
· Escribir un script que al pasarle por argumento un parámetro, determine si es archivo,
directorio, o si el parametro no existe.
#!/bin/bash
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio."
elif test -f $1 then
echo "$1 es un archivo."
else
echo "$1 no existe."
fi
· Escribir un script que al pasarle por argumento un archivo o directorio, devuelva el tamaño
en MB.
#!/bin/bash
# Este script recibe por argumento un archivo o directorio y devuelve el tamaño en MB.
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio y su tamaño es el siguiente:"
du -hs $1
elif test -f $1 then
echo "$1 es un archivo regular y su tamaño es el siguiente:"
du -hs $1
else echo "$1 no existe."
fi
· Recibir un nombre de archivo como parámetro e indicar, imprimiendo todas las leyendas
que correspondan, si el archivo es legible, modificable y ejecutable por el usuario.
#!/bin/bsh
# carsarch.sh: características de un archivo
echo Caracteristicas del archivo $1
if [ -r $1 ]
then
echo es legible
fi
if [ -w $1 ]
then
echo es grabable
fi
if [ -r $1 ]
then
echo es ejecutable
fi
· Recibir varios nombres de archivo como parámetros, y para cada uno validar si el nombre
corresponde a un archivo común existente, y si es así mostrarlo en pantalla paginando.
#!/bin/bash
# mostrarchs.sh: muestra contenido de varios archivos
for VAR in $*
do
if [ -f $VAR ]
then
more $VAR
else
echo No existe $VAR
fi
done
· Recibir un nombre de directorio, validar existencia y condición de directorio y mostrar
nombres de todos los directorios y subdirectorios bajo él.
#!/bin/bash
# esdir.sh: verifica directorio y muestra contenido recursivo
clear
if [ -d $1 ]
then
echo Directorios bajo $1
echo "Digite Enter para continuar"; read; clear
ls -lR $1 2>/dev/null | grep '^d' | pr -l24 | more -24
# el valor 24 en more es para visualizar en pantalla
else
echo No existe el directorio $1
fi
· Escribir un programa seaejec que reciba un nombre de archivo, verifique que existe y que
es un archivo común, lo convierta en ejecutable para el dueño y el grupo y muestre el
modo final.
#!/bin/bash
# seaejec: convierte un archivo en ejecutable
#
ARCH=$1
if [ -f $ARCH ] # existe y es archivo regular
then
chmod ug+x $ARCH
ls -l $ARCH
else
echo "seaejec: el archivo $ARCH no pudo ser convertido"
fi
· Escribir un programa copiabin.sh que mueva todos los programas del directorio actual
(archivos ejecutables) hacia el subdirectorio bin del directorio propio del usuario, muestre
los nombres de los que mueve e indique cuántos ha movido o que no ha movido ninguno.
Si el directorio bin no existe, deberá ser creado.
#!/bin/bash
# copiabin.sh: copia archivos ejecutables hacia $HOME/bin
#
# si el directorio bin no existe lo crea
if [ ! -d $HOME/bin ]
then
mkdir $HOME/bin
fi
# copia de archivos
N=0 # contador de archivos copiados
for ARCH in *
do
if [ -x $ARCH -a -f $ARCH ] # ejecutable y archivo común (no
directorio)
then
cp $ARCH $HOME/bin
echo " $ARCH fue copiado a $HOME/bin"
N=`expr $N + 1`
fi
done
if [ $N -eq 0 ]
then
echo "No se copió ningún archivo"
else
echo "Fueron copiados $N archivos"
fi
· Usando el archivo /etc/passwd escribir el programa usuarios que lista los nombres de
login, el directorio propio del usuario y el intérprete invocado por defecto de todos los
usuarios, ordenados alfabéticamente por nombre de login.
# usuarios: lista datos de usuarios
#
echo "Nombres de usuarios, Directorio propio, intérprete de comandos"
ypcat passwd | cut -d: -f1,6,7 | sort | more
echo
· Usando solamente el archivo /etc/group, escribir los siguientes programas:
o 'grupo1': listar los nombres y números de grupo y la lista de usuarios de cada uno,
ordenados por nombre.
o 'grupo2': igual, ordenados por número de grupo.
o 'grupo3': reúne las dos salidas anteriores, con leyendas explicativas adecuadas
para cada parte y para cada columna, así como nombre de la máquina y fecha del
día.
#!/bin/bash
#
# grupo1:
clear
echo "Grupos por nombre:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort | more -18
echo ---------------------------------------------------------
echo Digite Enter para continuar
read
clear
#!/bin/bash
#
# grupo2:
echo "Grupos por número:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort -t: -n +1 | more -18
echo ---------------------------------------------------------
echo
#!/bin/bash
#
# grupo3:
clear
./grupo1
echo
./grupo2
echo
echo Máquina: `hostname`
echo Fecha: `date`
· Escribir los siguientes programas:
o ligass: muestra los nombres de archivo que son enlaces simbólicos.
o ligash: muestra los archivos que tiene enlaces hard.
o Ambos programas reciben un nombre como como parámetro, y validarán que
corresponda a un directorio del sistema.
#!/bin/bash
# ligass: lista archivos que son enlace simbólico o tienen enlaces hard
# simbólicos: en ls -l se busca que empiece con l
if [ ! -d $1 ]
then
echo Error: ligas: $1 no es un directorio
exit
fi
echo Archivos que son enlace simbólico:
ls -l | grep "^l" | cut -56 -
echo
# hard: se busca 3 espacios y distinto de 1 como contador de enlaces
echo Archivos que tienen enlace hard:
ls -l | grep -v "^d" | cut -c11 - | grep -v "^ 1" | cut -c46 -
· Crear un script de Shell que monte la diskettera, copie todos los archivos (incluyendo
subdirectorios) de la diskettera a un directorio que se pase como parámetro, y luego
desmonte la diskettera. (Ayuda: para copiar tambien los subdirectorios, debe utilizarse un
comando recursivo)
#!/bin/bash
# disketera.sh
mount /floppy
cp -r /floppy $1
umount /floppy
· Crear un script de Shell que liste únicamente los nombres de los directorios que se
encuentran a partir del directorio actual.
#!/bin/bash
# direc.sh
for i in `ls`; do
if [ -d $i ]; then
echo $i
fi
done
· Realizar un script que espere hasta que un determinado proceso se ejecute. Y cuando ese
proceso se ejecuta, matarlo. (Ayuda: utilizar el comando killall).
#!/bin/bash
# kila.sh
while true; do
if ps ax | grep $1 | grep -v ' grep '; then
killall $1
fi
done
· Crear un script que reciba un directorio como primer parámetro, y a continuación una lista
de archivos. El script debe validar que los parámetros recibidos sean realmente archivos y
luego copiarlos al directorio recibido.
#!/bin/bash
# copiadir.sh
if [ -d $1 ]; then
nombre_dir=$1
shift
for i in $*; do
if [ -f $i ]; then
cp $i $nombre_dir
else
echo "El archivo $i no es válido"
fi
done;
else
echo "El primer parámetro debe ser un directorio!"
fi
· Escribir un script que al ejecutarlo como root reinicie el equipo después de 1 minuto.
#!/bin/bash
# Este script reiniciará el equipo después de 1 minuto al ejecutarlo como root.
if [ "$(whoami)" = 'root' ] then
shutdown -r +1
else
echo "El script no se ejecutará porque usted no es usuario 'root'".
fi
· Escribir un script que genere un backup del directorio de trabajo /home/jaime/work cada 5
minutos asignándole el nombre de "backup-hora de generación".
#!/bin/bash
# Este script genera un backup del directorio de trabajo /home/jaime/work
"crontab -e"
*/5 * * * * /home/jaime/work/10
cp -r /home/jaime/work /home/jaime/work/backup_$(date +%H%M%S)
· Escribir un script que encienda el LED del teclado numerico al ejecutar el script desde la
consola tty1 y apague el LED de CAPS (mayusculas).
#!/bin/bash
setleds -D +num >> /dev/tty1
setleds -D -caps >> /dev/tty1
· Escriba un script que elimine un archivo o directorio pasado como parámetro, y le pregunte
si está seguro de llevar a cabo la acción.
#!/bin/bash
rm –r $1
directorio, o si el parametro no existe.
#!/bin/bash
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio."
elif test -f $1 then
echo "$1 es un archivo."
else
echo "$1 no existe."
fi
· Escribir un script que al pasarle por argumento un archivo o directorio, devuelva el tamaño
en MB.
#!/bin/bash
# Este script recibe por argumento un archivo o directorio y devuelve el tamaño en MB.
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio y su tamaño es el siguiente:"
du -hs $1
elif test -f $1 then
echo "$1 es un archivo regular y su tamaño es el siguiente:"
du -hs $1
else echo "$1 no existe."
fi
· Recibir un nombre de archivo como parámetro e indicar, imprimiendo todas las leyendas
que correspondan, si el archivo es legible, modificable y ejecutable por el usuario.
#!/bin/bsh
# carsarch.sh: características de un archivo
echo Caracteristicas del archivo $1
if [ -r $1 ]
then
echo es legible
fi
if [ -w $1 ]
then
echo es grabable
fi
if [ -r $1 ]
then
echo es ejecutable
fi
· Recibir varios nombres de archivo como parámetros, y para cada uno validar si el nombre
corresponde a un archivo común existente, y si es así mostrarlo en pantalla paginando.
#!/bin/bash
# mostrarchs.sh: muestra contenido de varios archivos
for VAR in $*
do
if [ -f $VAR ]
then
more $VAR
else
echo No existe $VAR
fi
done
· Recibir un nombre de directorio, validar existencia y condición de directorio y mostrar
nombres de todos los directorios y subdirectorios bajo él.
#!/bin/bash
# esdir.sh: verifica directorio y muestra contenido recursivo
clear
if [ -d $1 ]
then
echo Directorios bajo $1
echo "Digite Enter para continuar"; read; clear
ls -lR $1 2>/dev/null | grep '^d' | pr -l24 | more -24
# el valor 24 en more es para visualizar en pantalla
else
echo No existe el directorio $1
fi
· Escribir un programa seaejec que reciba un nombre de archivo, verifique que existe y que
es un archivo común, lo convierta en ejecutable para el dueño y el grupo y muestre el
modo final.
#!/bin/bash
# seaejec: convierte un archivo en ejecutable
#
ARCH=$1
if [ -f $ARCH ] # existe y es archivo regular
then
chmod ug+x $ARCH
ls -l $ARCH
else
echo "seaejec: el archivo $ARCH no pudo ser convertido"
fi
· Escribir un programa copiabin.sh que mueva todos los programas del directorio actual
(archivos ejecutables) hacia el subdirectorio bin del directorio propio del usuario, muestre
los nombres de los que mueve e indique cuántos ha movido o que no ha movido ninguno.
Si el directorio bin no existe, deberá ser creado.
#!/bin/bash
# copiabin.sh: copia archivos ejecutables hacia $HOME/bin
#
# si el directorio bin no existe lo crea
if [ ! -d $HOME/bin ]
then
mkdir $HOME/bin
fi
# copia de archivos
N=0 # contador de archivos copiados
for ARCH in *
do
if [ -x $ARCH -a -f $ARCH ] # ejecutable y archivo común (no
directorio)
then
cp $ARCH $HOME/bin
echo " $ARCH fue copiado a $HOME/bin"
N=`expr $N + 1`
fi
done
if [ $N -eq 0 ]
then
echo "No se copió ningún archivo"
else
echo "Fueron copiados $N archivos"
fi
· Usando el archivo /etc/passwd escribir el programa usuarios que lista los nombres de
login, el directorio propio del usuario y el intérprete invocado por defecto de todos los
usuarios, ordenados alfabéticamente por nombre de login.
# usuarios: lista datos de usuarios
#
echo "Nombres de usuarios, Directorio propio, intérprete de comandos"
ypcat passwd | cut -d: -f1,6,7 | sort | more
echo
· Usando solamente el archivo /etc/group, escribir los siguientes programas:
o 'grupo1': listar los nombres y números de grupo y la lista de usuarios de cada uno,
ordenados por nombre.
o 'grupo2': igual, ordenados por número de grupo.
o 'grupo3': reúne las dos salidas anteriores, con leyendas explicativas adecuadas
para cada parte y para cada columna, así como nombre de la máquina y fecha del
día.
#!/bin/bash
#
# grupo1:
clear
echo "Grupos por nombre:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort | more -18
echo ---------------------------------------------------------
echo Digite Enter para continuar
read
clear
#!/bin/bash
#
# grupo2:
echo "Grupos por número:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort -t: -n +1 | more -18
echo ---------------------------------------------------------
echo
#!/bin/bash
#
# grupo3:
clear
./grupo1
echo
./grupo2
echo
echo Máquina: `hostname`
echo Fecha: `date`
· Escribir los siguientes programas:
o ligass: muestra los nombres de archivo que son enlaces simbólicos.
o ligash: muestra los archivos que tiene enlaces hard.
o Ambos programas reciben un nombre como como parámetro, y validarán que
corresponda a un directorio del sistema.
#!/bin/bash
# ligass: lista archivos que son enlace simbólico o tienen enlaces hard
# simbólicos: en ls -l se busca que empiece con l
if [ ! -d $1 ]
then
echo Error: ligas: $1 no es un directorio
exit
fi
echo Archivos que son enlace simbólico:
ls -l | grep "^l" | cut -56 -
echo
# hard: se busca 3 espacios y distinto de 1 como contador de enlaces
echo Archivos que tienen enlace hard:
ls -l | grep -v "^d" | cut -c11 - | grep -v "^ 1" | cut -c46 -
· Crear un script de Shell que monte la diskettera, copie todos los archivos (incluyendo
subdirectorios) de la diskettera a un directorio que se pase como parámetro, y luego
desmonte la diskettera. (Ayuda: para copiar tambien los subdirectorios, debe utilizarse un
comando recursivo)
#!/bin/bash
# disketera.sh
mount /floppy
cp -r /floppy $1
umount /floppy
· Crear un script de Shell que liste únicamente los nombres de los directorios que se
encuentran a partir del directorio actual.
#!/bin/bash
# direc.sh
for i in `ls`; do
if [ -d $i ]; then
echo $i
fi
done
· Realizar un script que espere hasta que un determinado proceso se ejecute. Y cuando ese
proceso se ejecuta, matarlo. (Ayuda: utilizar el comando killall).
#!/bin/bash
# kila.sh
while true; do
if ps ax | grep $1 | grep -v ' grep '; then
killall $1
fi
done
· Crear un script que reciba un directorio como primer parámetro, y a continuación una lista
de archivos. El script debe validar que los parámetros recibidos sean realmente archivos y
luego copiarlos al directorio recibido.
#!/bin/bash
# copiadir.sh
if [ -d $1 ]; then
nombre_dir=$1
shift
for i in $*; do
if [ -f $i ]; then
cp $i $nombre_dir
else
echo "El archivo $i no es válido"
fi
done;
else
echo "El primer parámetro debe ser un directorio!"
fi
· Escribir un script que al ejecutarlo como root reinicie el equipo después de 1 minuto.
#!/bin/bash
# Este script reiniciará el equipo después de 1 minuto al ejecutarlo como root.
if [ "$(whoami)" = 'root' ] then
shutdown -r +1
else
echo "El script no se ejecutará porque usted no es usuario 'root'".
fi
· Escribir un script que genere un backup del directorio de trabajo /home/jaime/work cada 5
minutos asignándole el nombre de "backup-hora de generación".
#!/bin/bash
# Este script genera un backup del directorio de trabajo /home/jaime/work
"crontab -e"
*/5 * * * * /home/jaime/work/10
cp -r /home/jaime/work /home/jaime/work/backup_$(date +%H%M%S)
· Escribir un script que encienda el LED del teclado numerico al ejecutar el script desde la
consola tty1 y apague el LED de CAPS (mayusculas).
#!/bin/bash
setleds -D +num >> /dev/tty1
setleds -D -caps >> /dev/tty1
· Escriba un script que elimine un archivo o directorio pasado como parámetro, y le pregunte
si está seguro de llevar a cabo la acción.
#!/bin/bash
rm –r $1
No hay comentarios:
Publicar un comentario