FORUM DARKERS

Olá galera, sei que muitos aqui estão enjuados ou coisa do tipo de tanto vêr sobre Shell script e záz.  ;D

Bem aqui peguei algumas informações em Home pages, Livros e algumas Revistas. Se virem alguma Home page com assunto semelhante ou relacionado porquê, foi copiado ou add de algum lugar vlw?

Let's Go!

= = = = == = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

Shell scripts

--------------------------------------------------------------------------------

Estrutura geral de um script em BASH-Shell
Os arquivos de script permitem construir esquemas de execução complexos a
partir dos comandos básicos do shell. A forma mais elementar de arquivo de
script é apenas um conjunto de comandos em um arquivo texto, com permissões
de execução habilitadas. O arquivo backup, cujo conteúdo é mostrado a
seguir, é um exemplo de script:

echo "Iniciando backup..."

# montar o diretório do servidor de backup
mount backserver.ppgia.pucpr.br:/backup /backup

# efetuar o backup em um arquivo tar compactado
tar czf /backup/home.tar.gz /home

# desmontar o diretório do servidor de backup
umount /backup

echo "Backup concluido !"
Quando o script backup for executado, os comandos do arquivo serão
executados em seqüência pelo shell corrente (de onde ele foi lançado).
Assim, se o usuário estiver usando o shell bash, os comandos do script serão
executados por esse shell. Como isso poderia gerar problemas em scripts
usados por vários usuários, é possível forçar a execução do script com um
shell específico (ou outro programa que interprete os comandos do arquivo).
Para isso é necessário informar ao sistema operacional o programa a ser
usado, na primeira linha do arquivo do script:

#!/bin/bash --noprofile
# A opção --noprofile inibe a leitura dos arquivos de inicialização
# do shell, tornando o lançamento do script muito mais rápido.

# comandos de um script em Bash-Shell
server=backserver.ppgia.pucpr.br
backdir=/backup
...
exit 0
Com isso, será lançado um shell bash separado, somente para interpretar as
instruções do script. O shell será terminado pelo comando exit, cujo
parâmetro é devolvido ao shell inicial através da variável $?. Esse
procedimento pode ser usado para lançar scripts para outros shells, ou mesmo
outros programas, como perl, awk, sed, etc.


---------------------------------------------------------------------------------------------------------------

Parâmetros de entrada
Os argumentos da linha de comando são passados para o shell através da
variável local $argv. Os campos individuais dessa variável podem ser
acessados como em uma variável local qualquer. Além disso, uma série de
atalhos é definida para facilitar o acesso a esses parâmetros:

·         $0 : o nome do script

·         $n : o n-ésimo argumento

·         $* : todos os argumentos

·         $# : quantidade de argumentos

·         $? : status do último comando executado (0 = verdadeiro e 1 =  falso)

·         $$ : número de processo (PID) do shell que executa o script

Vejamos um exemplo através do script listaparams:

#!/bin/bash

# exemplo de uso dos parâmetros de entrada

echo "Nome do script : $0"

echo "Primeiro parâmetro : $1"

echo "Todos os parâmetros : $*"

echo "Numero de parametros : $#"

echo "Numero deste processo : $$"

exit 0

Chamando o script acima com alguns parâmetros obtemos a seguinte resposta:

ppgia:~> listaparams banana tomate pessego melao pera uva

Nome do script : listaparams

Primeiro parâmetro : banana

Todos os parâmetros : banana tomate pessego melao pera uva

Numero de parametros : 6

Numero deste processo : 2215

ppgia:~>


-----------------------------------------------------------------------------------------------------------------

Controle de fluxo
Existem diversos construtores de controle de fluxo que podem ser usados em
scripts BASH-Shell. Os principais são:

·         if-then :

        if ( condição ) then
               ...
        fi
·         if-then-else:

        if ( condição ) then
               ...
        else
               ...
        fi
·         if-then-elif-else:

        if ( condição ) then
               ...
        elif
               ...
        else
               ...
        fi
·         for loop :

        for variável in lista de valores
        do
               ...
        done
·         while loop :

        while ( condição )
        do
               ...
        done
·         case :

        do case variável in
               string1)
                       ...
                       break;;
               string2)
                       ...
               break;;
               *):
                       ...
                       break;;
        esac
·         select :

        select variável in lista de valores
        do
               ...
        done
Além das estruturas acima, algumas outras podem ser usadas para executar
comandos em situações específicas:

·         `comando`: substitui a expressão entre crases pelo resultado
(stdout) da execução do comando. Por exemplo, a linha de comando abaixo
coloca na variável arqs os nomes de arquivos retornados pelo comando find:

arqs=`find /etc -iname ´???´`
·         comando1; comando2; comando3: executa seqüencialmente os comandos
indicados:

cp *.c /tmp ; rm *.txt ; ls -l
·         ( comando ) : executa o comando entre parênteses em um sub-shell
(lança um shell separado e passa o comando como parâmetro). Por exemplo:

( ls -l > stdout.txt ) 2> stderr.txt
O exemplo acima é bastante usado para separar as saídas stderr e stdout nos
shells da família bash.

Exemplo utilizando select e case.

      #!/bin/bash

      PS3="Please enter a number "

        select i in fo*

           do case $i in

              food|fool|foot)

                 echo "good choice"

                 break;;

              for|foxy)

                 echo 'poor choice'

                 echo 'Invalid number'

                 break;;

              *)

                 echo try again;;

           esac

        done

Exemplo testando o retorno de um comando.

      #!/bin/bash

      ls /etc/passwd >/dev/null 2>&1

      if [ $? ]

      then

            echo "Existe o arquivo"

      else

            echo "Arquivo nao existe!!!"

      fi


------------------------------------------------------------------------------------------------------------------

Operadores lógicos e aritméticos
Para implementar as estruturas de controle de fluxo é necessário definir
condições, que podem ser feitas através de testes. Podemos efetuar
comparações entre expressões (deve-se utilizar [ ] ou o comando test no if)
através dos seguintes operadores:

·         Comparações entre números:

-eq igual a
-ge maior ou igual
-gt maior que
-le menor ou igual
-lt menor que
-ne diferente (não igual)
·         Comparações entre strings:

== != < >
·         Conectivos lógicos (and, or):

-a -o
·         Operadores lógicos bit a bit:

! & | << >>
·         Operadores aritméticos:

+ - * / %
Para realizar uma operação matemática, é melhor utilizar a seguinte notação
var=$((var1 expressão var2))

Vejamos alguns exemplos de expressões usando os operadores acima definidos:

if [ "$LOGNAME" == "root" ]

then

...

fi



while test "$1" != ""

do

echo "Parâmetro $1"

shift

done



if [ $# -le 3 ]

then

echo "Número insuficiente de parâmetros de entrada"

fi

CONTADOR=1

while [ $CONTADOR -le 10 ]

do

echo "Número $CONTADOR"

CONTADOR=$((CONTADOR+2))

done



if [ `who | wc -l` -ge $maxusers ]

then

echo "Login negado, pois há mais de $maxusers usuários conectados."

logout

else

fi


--------------------------------------------------------------------------------

Operadores de teste em arquivos e strings
Os operadores de teste em arquivos e strings permitem verificar propriedades
de entradas no sistema de arquivos. Eles são usados na forma "-op", onde op
corresponde ao teste desejado. Os principais testes são:

·         e : a entrada existe

·         r : a entrada pode ser lida

·         w : a entrada pode ser escrita

·         O : usuário é o proprietário da entrada

·         s : tem tamanho maior que zero

·         f : é um arquivo normal

·         d : é um diretório

·         L : é um link simbólico

·         b : é um dispositivo orientado a bloco

·         c : é um dispositivo orientado a caracatere

·         p : é um named pipe (fifo)

·         S : é um socket special file

·         u : tem o bit SUID habilitado

·         g : tem o bit SGID habilitado

·         G : grupo da entrada é o mesmo do proprietário

·         k : stick bit está habilitado

·         x : a entrada pode ser executada

·         z : a string  tem tamanho zero

·         n : a string  tem tamanho diferente de zero

·         nt: Verifica se um arquivo é mais novo que outro

·         ot: Verifica se um arquivo é mais velho que outro

·         ef: Verifica se é o mesmo arquivo (link)

  Vejamos um exemplo de uso desses operadores:

arquivo='/etc/passwd'

if [ -e $arquivo ]

then

if [ -f $arquivo ]

then

if [ -r $arquivo ]

then

source $arquivo

else

echo "Nao posso ler o arquivo $arquivo"

fi

else

echo "$arquivo não é um arquivo normal"

fi

else

echo "$arquivo não existe"

fi





#!/bin/bash

arq1=$0

arq2='/etc/passwd'

arq3='/etc/passwd'

if [ $arq1 -nt $arq2 ]

then

echo "Arquivo $arq1 eh mais novo que $arq2"

fi

if [ $arq1 -ot $arq2 ]

then

            echo "Arquivo $arq1 eh mais velho que $arq2"

fi

if [ $arq3 -ef $arq2 ]

then

echo "Trata-se do mesmo arquivo"

fi


As opções podem ser agrupadas em um único teste. Por exemplo, "-erf arquivo"
testa se o arquivo indicado existe, se é um arquivo normal e se pode ser
lido:

arquivo='/etc/passwd'

if [ -efr $arquivo ]

then

source $arquivo

else

echo "Problemas no acesso a $arquivo"

fi


--------------------------------------------------------------------------------

Expansão de variáveis
Muitas vezes é necessário pegar apenas uma parte de uma variável. Neste
caso, é possível utilizar os caracteres de expansão de variáveis para pegar
partes de uma string. Alguns parâmetros de expansão são:

·         ${parâmetro#padrão}: Remove a menor parte a esquerda da parâmetro.

·         ${parâmetro##padrão}: Remove a maior parte a esquerda da
parâmetro.

·         ${parâmetro%padrão}: Remove a menor parte a direita da parâmetro.

·         ${parâmetro%%padrão}: Remove a maior parte a direita do parâmetro.

·         ${parâmetro//padrão/string}: Substitui o padrão pela nova string
do parâmetro.

·         ${parâmetro:início:tamanho}: Pega uma parte da variável.

Existe vários outros, consulte o comando bash (man bash) para maiores
detalhes.

Vejamos script de exemplo do uso desses modificadores:

#!/bin/bash

texto="/etc/passwd"

echo "Tirando o nome do arquivo = ${texto%passwd}"

echo "Tirando o caminho do arquivo = ${texto#/etc/}"

echo "Substituindo passwd por group = ${texto//passwd/group}"



#!/bin/bash

meses=( Janeiro, Fevereiro, Marco, Abril, Maio, Junho, Julho, Agosto,
Setembro, Outubro, Novembro, Dezembro )

echo

echo "Entre com Uma data no formato dd/mm/aaaa :"

read data

dia=${data:0:2}

mes=${data:3:2}

ano=${data:6:4}

echo

echo "A data digitada foi $dia de ${meses[$mes-1]} de $ano"

echo


-----------------------------------------------------------------------------------------------------------------

Um exemplo simples de script
Analise e descreva o que faz o script a seguir, passo a passo:

#!/bin/bash --noprofile



# testar se ha um so parametro de entrada

if [ $# != 1 ]

then

echo "Erro na chamada"

echo "Uso: criadir numero de diretorios"

exit 1

fi



num=0



while [ $num -lt $1 ]

done

echo "Criando diretorio $num"

mkdir dir$num

num=$((num+1))

done



echo "Acabei de criar $1 diretorios"

exit 0

Agora, digite o script acima descrito no arquivo meuscript, em sua área de
trabalho, e teste-o.

Ps: Exemplos avançados, você encontrará nos Posts do nosso amigo CLoudy

------------------------------------------------------------------------------------------------------------------
Há, uma coisa pra ajudar vocês a li dár um pouco mais cedo com essa Linguagem Fantástica.

Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:

#!/bin/sh

cd /tmp
find . -type f -mtime +30 -delete

Este vem ao caso ser o conteúdo de um shell script que sempre que fosse executado apagaria arquivos com data de modificação maior que 30 dias a partir do diretório /tmp do sistema de arquivos. (Assim como alguns códigos de outras linguagens são usadas no Windows)
------------------------------------------------------------------------------------------------------------------

Fontes: Várias
Postado e Resumido por: Mim (Quak2)

Bem galerinha vou nessa..
Abraços por trás aew ... kpeakepekapea
;)

Ponto!

vlw

locator.dll

ótimo tuto, bom post em

Muito bom Quak2....

e issoaee cara... ta de parabens mereceu mesmo esse ponto +


flw brother.....


^^

nao tem tempo de ler tudo mas

mount backserver.ppgia.pucpr.br:/backup /backup
isso e e a primeira vez que eu vejo isso

Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:
dê uma lida no /etc/init.d/bootmisc.sh

rog

Aê brother, voltando a ativa né... Abraços...

Quote from: "rog"nao tem tempo de ler tudo mas

Code Select Expand

mount backserver.ppgia.pucpr.br:/backup /backup
isso e e a primeira vez que eu vejo isso

Code Select Expand

Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:
dê uma lida no /etc/init.d/bootmisc.sh

rog

@rog
Bem quanto á sua 1ª coisa nunca vista, é só um Exemplo de server de backup, só citei ali a variada, tendeu man?
Quando ao "Dê uma lida" verifiquei manu, vlw (Y)
Qqer coisa, só chamar.
abraço

Muito bom cara.