**************************
**************************
Global Replace
---------------------------------------------------------------------
Este shell script pode vir a ser util. O que ele faz e simplesmente
trocar todas as ocorrencias de determinado string por uma outra
em uma numero de arquivos especificados na linha de comando,
aceitando inclusive wildcards.
Por exemplo, o comando
% repl rubens joao *
substituiria todas as ocorrencias de "rubens" por "joao" em todos
os arquivos do diretorio corrente.
Alem disto, este shell script aborda alguns pontos interessantes
com relacao a programacao shell.
O codigo da shell foi comentado para esclarecer as tecnicas de
programacao.
#! /bin/sh
# Teste para verificar se todos os argumentos foram passados
# na linha de comando (minimo de 3, duas strings (de, para) e
# nome(s) do(s) arquivo(s). Se nao, sai e envia mensagem de erro
if [ $# -lt 3 ]
then
echo "Uso $0: DE-argumento PARA-argumento arquivos" >&2
exit 1
fi
# atribui a variavel DE o valor da string a ser substituida
# e desloca as variaveis ($3 passa a ser $2, $2 passa a ser $1)
# O deslocamento das variaveis e feito com o comando shift
DE=$1; shift
# atribui a variavel PARA o valor final da string
# $1 agora e o argumento de numero 2, string destino.
PARA=$1; shift
# Na entrada do laco, $1 representa o nome do primeiro arquivo
# onde serao efetuadas as alteracoes
until [ $# -eq 0 ]
# Continua no laco ate que o numero de argumentos seja igual a zero
# ou seja, ate que nao existam mais arquivos a serem processados.
do
# Testa a existencia do arquivo
if [ ! -r $1 ]
then echo "no file $1" >& 2;shift
# A modificacao nos arquivos e feita com o comando sed, que redireciona
# a saida para um arquivo temporario, que ira possuir o nome do shell ($0)
# seguido do numero de identificacao do processo ($$)
else sed -e "s/$DE/$PARA/g" $1 > /tmp/$0$$
mv /tmp/$0$$ $1;
echo "alteracoes efetuadas em $1" >&2
shift
fi
**********************************************************************************************
Criacao de Scripts com o bit de execucao ligado
---------------------------------------------------------------------
Muitas vezes criamos shell scripts com o programa vi. Todavia
o modo de execucao destes arquivos normalmente (dependendo do
valor que voce definiu para o umask) e 644, ou seja, voce nao
consegue executar este arquivo.
Um script bastante simples que resolve este pequeno incomodo
e o script xvi (eXecutable vi). Ele usa o vi normalmente para
se editar o arquivo, porem, apos o fim da edicao, seta o modo
de execucao do script.
Agora, o script:
-------------------------------------------------------------------------xvi
#!/bin/sh
#
# Autor: Queiroz
# Data : 11/08/94
#
# Este shell script permite a edicao de arquivos executaveis
# alterando as permissoes default para o modo 755
#
if [ $# -eq 0 ]; then
echo 1>&2 Sintaxe: $0 arquivo[s]
exit 1
fi
for file
do
vi $file
chmod 755 $file
done
...
Bastante simples, nao?
----------------------------------------------
**********************************************************************************************
Gerenciamento de Espaco em Disco
---------------------------------------------------------------------
A tarefa de manter espaco em disco em quantidade suficiente
para que os usuarios consigam trabalhar e o sistema operacional
consiga funcionar decentemente e uma das mais importantes
do administrador de sistemas.
O comando "find" e uma ferramenta excelente para desempenhar este
tipo de tarefa.
Existem arquivos que aparecem no sistema de tempos em tempos
e que ocupam um espaco consideravel e nao servem para nada.
Arquivos chamados "core" por exemplo sao resultados de um dump
de memoria realizado por um programa para que o programador
determine o que ocorreu de errado. Normalmente a maioria
das pessoas nao se dao ao trabalho de remover estes arquivos
e eles continuam a existir no seu disco por um longo tempo,
apenas ocupando espaco.
Arquivos postscript tambem ocupam muito espaco. Nao recomendo
que se remova estes arquivos, mas pelo menos eles podem
ser compactados.
Arquivos ha mais de um dia sem serem modificados e residentes no diretorio
/tmp, tambem nao devem continuar vivendo.
Alguns administradores tambem tem por habito remover os arquivos
chamados a.out (embora isto possa gerar atritos com alguns usuarios).
Tambem pode ser interessante descobrir quem esta abrigando
arquivos realmente grandes em seus diretorios para se tomar
providencias.
Bem, a descoberta de todos estes arquivos e as acoes apropriadas
podem ser tomadas automaticamente atraves de um simples shell script:
---------------------------------------------------------------------
#! /bin/sh
# Encontra e apaga arquivos chamados core
find / -name core -print | xargs rm
# Encontra e compacta arquivos postscript
find / -name \*.ps -print | xargs gzip
# Encontra e remove arquivos chamados a.out
find / -name a.out -print | xargs rm
# Descobre arquivos maiores que 2048 blocos de 512 bytes e envia a relacao
# para o administrador de sistemas
find / -size +2048 -print | xargs ls -l | mail root
# Apaga arquivos residentes no diretorio /tmp que nao tenham sido
# modificados ha mais de um dia
find /tmp -mtime +1 -print | xargs rm
------------------------------------------------------------
**********************************************************************************************
Verificacao dos argumentos em shell scripts
---------------------------------------------------------------------
E fundamental que todo shell script verifique, antes de realizar qualquer
acao, que o numero correto de argumentos foi fornecido por quem invoca o
programa:
#!/bin/sh
if [ $# -ne 3 ]; then
echo 1>&2 Sintaxe: $0 a b c
exit 999
fi
O script acima requer tres argumentos que, se nao forem fornecidos,
impedem a execucao do programa e seta o codigo de retorno com o valor
999. Normalmente um codigo de retorno diferente de zero indica a ocorrencia
de um erro.
Outro exemplo, o programa tiraacento, ja veiculado nesta lista:
#! /bin/sh
MACROS=/home/queiroz/bin
infile=$1
outfile=$2
# Neste ponto verifica-se se o numero de argumentos fornecido
# foi igual a dois. Caso contrario, e escrito na tela uma mensagem
# indicando a sintaxe correta, atribuindo-se o valor 1 ao codigo de
# saida
if [ $# -ne 2 ]; then
echo 1>&2 Sintaxe: $0 arquivo_entrada arquivo_saida
exit 1
# Caso o numero de argumentos esteja correto, executa-se entao
# o programa
else
if [ -f $infile ]; then
# A funcao deste if e verificar se o arquivo de entrada existe
# Caso exista, entao e executado o comando, caso contrario,
# o processamento e encerrado com uma mensagem de erro e ao codigo
# de saida e atribuido o valor 1.
sed -f $MACROS/tiraacento.sed $infile > $outfile
else
# Nunca se esqueca do aviso de erro. Caso contrario o usuario
# do programa pode pensar que tudo deu certo.
echo "$infile nao existe!!! "
exit 1
fi
fi
-----------------------------------------------------
**********************************************************************************************
Atribuicao de Valores a Variaveis em Shell Scripts
---------------------------------------------------------------------
Variaveis sao sequencias de letras, digitos ou underscores, comecando com
uma letra ou underscore "_".
A atribuicao de valor a uma variavel ira depender da shell sendo utilizada.
Na Bourne shell e compativeis (sh), atribui-se o valor a uma variavel
da seguinte forma:
DATE=6jun60
A variavel DATE foi atribuido o valor 6jun60.
Outra caracteristica extremamente util e atribuir o valor de comandos
a variaveis. Por exemplo, suponhamos que queiramos que a variavel
DATE assuma o valor da data corrente, no formato mmddyy:
DATE=`date +%m%d%y`
O comando date, como especificado acima, ira retornar o valor
052797, onde 05 indica o mes de maio, 27 o dia do mes e 97 o dia do ano.
Importante notar as aspas invertidas "`". Ao se delimitar um comando
por aspas invertidas voce esta indicando que esta interessado no
resultado do comando, que por sua vez sera atribuido a variavel.
Por exemplo, se desejassemos enviar uma mensagem a todos os usuarios
de determinado computador:
#!/bin/sh
for user in `awk -F: '{print $1}' /etc/passwd`
do
mail -s "Aviso Importante" $user < mensagem.importante
echo $user
done
O shell script acima, ira obter, com o auxilio do programa awk, uma
listagem de todos os usuarios da maquina, enviando em seguida
uma mensagem a todos eles.
A variavel $user serao atribuidos tantos valores quantos os retornados
pelo comando
awk -F: '{print $1}' /etc/passwd
Observar que, no shell script, o comando esta delimitado
por aspas invertidas (`).
Como os campos no arquivo /etc/passwd sao delimitados por ":",
faz-se necessario a especificacao da diretiva "-F:" para
que o comando awk possa selecionar corretamente a identificacao
do usuario ($1, ou o primeiro campo).
Na linha onde se envia a mensagem
o caracter "<" indica que a mensagem a ser enviada encontra-se
dentro do arquivo "mensagem.importante". O titulo da mensagem e
informado atraves da diretiva "-s" seguida pelo valor "Aviso Importante".
O comando "echo $user" e apenas informativo e serve para monitorar o
progresso da execucao do comando.
--------------------------------------
**********************************************************************************************
Argumentos em Shell Scripts (Bourne Shell)
---------------------------------------------------------------------
A partir de hoje serao veiculadas algumas dicas sobre variaveis em
Shell scripts juntamente com exemplos de utilizacao.
Comecaremos com os argumentos passados na linha de comandos.
Estes argumentos recebem o nome de variaveis posicionais e sao identificadas
por $0, $1, $2, ...
A variavel $0 indica o comando emitido. Por exemplo, no comando
% ls a b c d
a variavel $0 assume o valor "ls". A variavel $1 recebe o valor "a",
a variavel $2 recebe o valor "b" e assim por diante.
Esta variavel e bastante utilizada para se enviar avisos ao usuario
quanto a sintaxe correta de uso de comandos. Por exemplo:
echo "Sintaxe: $0 arquivo_entrada arquivo_saida"
Se a linha acima se encontrasse em uma shell script chamada "chname"
e a invocassemos sem especificar corretamente
seus argumentos, receberiamos o seguinte aviso:
Sintaxe: chname arquivo_entrada arquivo_saida
----------------------------------------
**********************************************************************************************
Argumentos em Shell Scripts (Bourne Shell) (1)
---------------------------------------------------------------------
A partir de hoje serao veiculadas algumas dicas sobre variaveis em
Shell scripts juntamente com exemplos de utilizacao.
Comecaremos com os argumentos passados na linha de comandos.
Estes argumentos recebem o nome de variaveis posicionais e sao identificadas
por $0, $1, $2, ...
A variavel $0 indica o comando emitido. Por exemplo, no comando
% ls a b c d
a variavel $0 assume o valor "ls". A variavel $1 recebe o valor "a",
a variavel $2 recebe o valor "b" e assim por diante.
$#
Numero de argumentos fornecidos. Constitui uma norma de boa
programacao verificar este valor no inicio da shell e emitir
mensagem de erro caso incorreto.
$*
Todos os argumentos fornecidos como uma string separada por brancos.
$?
Codigo de retorno. Codigos de retorno iguais a zero indicam que o programa
conseguiu executar sua tarefa com sucesso, ao passo que valores diferentes
indicam algum tipo de erro. Este valor pode ser setado de dentro de uma
shell atraves da diretiva "exit".
$$
Identificacao do processo executando a shell. Bastante util para criacao
de arquivos temporarios.
**********************************************************************************************
Argumentos em Shell Scripts (Bourne Shell) (2)
---------------------------------------------------------------------
$#
Numero de argumentos fornecidos. Constitui uma norma de boa
programacao verificar este valor no inicio da shell e emitir
mensagem de erro caso incorreto.
Por exemplo:
#!/bin/sh
if [ $# -ne 2 ]; then
echo 1>&2 Sintaxe: $0 in out
exit 1
fi
No exemplo acima, se nao forem fornecidos dois argumentos e exibida
uma mensagem de erro para o usuario e e setado o codigo de retorno
com o valor 1 para indicar que houve um erro de processamento.
-----------------------------
**********************************************************************************************
Argumentos em Shell Scripts (Bourne Shell) (3)
---------------------------------------------------------------------
$?
Codigo de retorno do ultimo comando executado.
Codigos de retorno iguais a zero indicam que o programa
conseguiu executar sua tarefa com sucesso, ao passo que valores diferentes
indicam algum tipo de erro. Este valor pode ser setado de dentro de uma
shell atraves da diretiva "exit".
Por exemplo:
if [ $? -eq 0 ]; then
mv file file.old
else
mv file file.err
fi
No exemplo acima e testado o resultado do ultimo comando executado.
Se for 0 (tudo ok) o arquivo chamado file e renomeado para file.old.
Caso algum erro tenha ocorrido, o arquivo file e renomeado para file.err.
---------------------------------------
**********************************************************************************************
Argumentos em Shell Scripts (Bourne Shell) (4)
---------------------------------------------------------------------
$$
Identificacao do processo executando a shell. Bastante util para criacao
de arquivos temporarios.
Por exemplo:
tmpfile=/tmp/file$$
sed -e "s/$DE/$FROM" $1 > $tmpfile
mv $tmpfile $1
No exemplo acima, o arquivo fornecido como argumento na linha de comandos
e editado pelo comando sed, onde todas as strings identificadas pela
variavel $DE sao substituidas pela string identificada pela variavel
$PARA e a saida e gravada no arquivo /tmp/file$$ ($tmpfile).
Apos a execucao do comando sed o arquivo temporario e novamente gravado
como $1 (arquivo original).
-----------------------
**********************************************************************************************
Programacao Shell - Caracteres Especiais
---------------------------------------------------------------------
Deve-se tomar cuidados especiais, na programacao shell, com os
chamados caracteres especiais. Sao eles:
; & () ^ < > espacos, tabulacao e new-line
Sao utilizados para encadear comandos (;), tarefas batch, etc.
Para utilizar qualquer um destes caracteres em um contexto diferente
de seu significado original, faz-se necessario precede-los por "\"
(backslash ou barra invertida), ou delimita-los pelo caracter ".
Por exemplo, se quisermos achar todos os caracteres iniciados
por rubens, nao importa a terminacao, utilizamos o comando find
da maneira abaixo:
find / -name rubens\* -print
ou
find / -name "rubens*" -print
O caracter "*", caso nao precedido pela "\" ou delimitado pelas aspas
(") e interpretado pela shell em uso e nao pelo comando find, resultando em
erro:
% find . -name 97* -print
find: missing conjunction
Ja o comando:
% find . -name 97\* -print
funciona perfeitamente :-)
----------------------------------
**********************************************************************************************
Debugging shell scripts
---------------------------------------------------------------------
Ao se invocar uma shell com a flag -x, serao exibidos todos os comandos
executados, atribuicao de valores a variaveis, permitindo o acompanhamento
do processamento e deteccao de eventuais falhas.
Por exemplo, a shell
---------------------------------------------------------------------
#!/bin/sh -x
echo `date`
---------------------------------------------------------------------
ira exibir a seguinte saida:
date
echo Tue May 27 20:26:11 GRNLNDDT 1997
Tue May 27 20:26:11 GRNLNDDT 1997
------------------------------------------
**********************************************************************************************
catalog
---------------------------------------------------------------------
As vezes, e se voce tem espaco em disco para tanto, voce ir acumulando
inumeros arquivos em seu diretorio home.
Ou seja, voce pode (e certamente vai) se esquecer de coisas importantes
que possui e pode tambem vir a deixar muito lixo se acumular dentro
de seu computador.
Uma shell script interessante que pode lhe ajudar a reencontrar velhos
amigos e se livrar daquilo que nao interessa mais, e o script catalog,
incluido nesta dica.
Ele ira gerar uma listagem do conteudo de seu diretorio, ou de qualquer
outro, que voce podera entao analisar e tomar as decisoes adequadas.
Veja um exemplo da saida deste comando:
[ TT_DB ]
. access_table.ind
. access_table.rec
. file_object_map.ind
*TT_DB
[ adm ]
. [ acct ]
foreach: No match.
. *acct
. [ cron ]
[ bin ]
. *CC_r4
. *Mail
. *Rsh
. [ X11 ]
. . *X
. . X.exp
Os diretorios encontram-se delimitados por "[" e "]".
Os pontos significam a profundidade da estrutura de diretorios.
Nomes de arquivos precedidos por "*" indicam que o arquivo e executavel.
E finalmente, o script catalog.
Este script foi escrito por Ken Turkowski, e faz parte de um conjunto
enorme de scripts e dicas de configuracao de shells compilada por
Nancy Blachman e que se encontra hoje em
http://ftp.unicamp.br/pub/unix-c/info/unix-tricks.txt.gz.
#!/bin/csh
#
# catalog - produce complete file structure list from directory
# Parameters: 1: directory name (optional)
# 2: indentation string (empty on first call)
#
# Produces on standard output the file structure emanating from
# the current directory. Each descent into a subdirectory
# is indicated by further indentation. Directories are indicated
# by surrounding [], and executable files are prefaced with a *.
#
if ( $#argv == 0) then
echo "file structure from directory `pwd`"
date
echo ''
else
cd $1
endif
foreach i ( * )
if ( -d $i ) then
echo "${2}[ $i ]"
$0 $i "$2 . "
endif
if ( "$i" != '*' ) then
if ( -x $i ) then
echo "${2} *$i "
else
echo "${2} $i "
endif
endif
endif
end
**********************************************************************************************
pathname
---------------------------------------------------------------------
Quando se deseja saber onde se encontra determinado programa, o
comando which pode ser utilizado.
Por exemplo, se eu desejar saber onde se encontra, dentro do
path que eu criei, o programa vi, eu posso obter esta informacao
atraves do comando:
% which vi
/bin/vi
Este comando ira varrer o path definido na variavel de ambiente
PATH e ira retornar a primeira ocorrencia encontrada. No caso acima,
sempre que o comando vi for invocado sera executado o programa
contido dentro do diretorio /bin.
Pode ocorrer entretanto de existirem varias versoes de um comando
dentro do path. Caso eu deseje conhece-las, o shell script abaixo
pode me dar esta informacao:
pathname
---------------------------------------------------------------------
#!/bin/csh
foreach cmddir ($path)
if ( -e $cmddir/$1 ) echo " $cmddir/$1"
end
---------------------------------------------------------------------
Para cada diretorio contido dentro da variavel path, sera testada
a existencia do comando fornecido ao ser invocada a shell.
Por exemplo:
% pathname vi
/bin/vi
/home/queiroz/bin/vi
Ou seja, alem do diretorio /bin, existe um comando chamado vi tambem
dentro do diretorio /home/queiroz/bin.
**********************************************************************************************
Redirecionamento do output do syslogd para um script
----------------------------------------------------------------------.Colaboracao de Antonio Paulo Salgado Forster
A sintaxe do syslog.conf so aceita direcionamento de 4 formas:
- arquivo
"mail.debug /var/log/sendmail"
- loghost
"mail.debug @loghost"
- usuarios
"mail.debug root"
- devices
"mail.debug /dev/console"
Dessa forma, nao ha como fazer um pipe redirecionando o output para um
script.
Muitos poderiam pensar em usar algo como no exemplo abaixo...
"mail.debug | /somedir/script"
... mas nao funciona.
A solucao esta em "enganar" o syslogd, deixando "ele pensar" que esta
mandado esse output para um arquivo, quando na realidade, ele nao esta.
Isso pode ser feito criando-se um pipe atraves do comando mkfifo(1).
unix# mkfifo novo_pipe
unix# ls -la novo_pipe
prw-r--r-- 1 user group 0 Jul 15 14:50 novo_pipe
Uma documentacao a respeito desse comando pode ser encontrada no proprio
manual (man mkfifo).
Agora, o que fazer com esse pipe? O que ele faz?
Esse pipe ("FIFO special file") direciona para stdout qualquer dado que
receba. Sendo assim, o que deve ser feito e' direcionar a saida do
syslogd para esse arquivo especial, e deixar um script tentando ler
dados desse pipe.
Nesse caso, um exemplo de como ficaria a linha no syslog.conf:
"mail.debug /somedir/novo_pipe"
Um teste de funcionamento desse pipe pode ser feito com os scripts a
seguir:
Criacao do pipe:
unix# mkfifo novo_pipe
unix# ls -la novo_pipe
prw-r--r-- 1 user group 0 Jul 15 14:50 novo_pipe
Um script de para ler os dados:
unix# cat > le_dados.pl
#!/usr/bin/perl -w
open P, "novo_pipe";
while (1) {
sleep 5;
open SAIDA, ">>saida";
print SAIDA "--->",$linha while ($linha=);
close SAIDA;
}
close P;
exit 0;
Um script para direcionar os dados ao pipe:
unix# cat > poe_dados.pl
#!/usr/bin/perl
open P , ">novo_pipe";
for ($x=1;$x<=10000;$x++) {print P "testando com 10000 linhas!!! >:) \n";}
close P;
exit 0;
unix# chmod 755 le_dados.pl poe_dados.pl <- da permissao de execucao
unix# le_dados.pl & <- inicia o script em backgroud
unix# ls -la
total 8
drwxr-xr-x 2 user group 512 Jul 15 10:09 .
drwxr-xr-x 7 user group 1024 Jul 15 10:09 ..
-rwxr-xr-x 1 user gtoup 144 Jul 14 15:19 le_dados.pl
prw-r--r-- 1 user group 0 Jul 14 15:25 novo_pipe
-rwxr-xr-x 1 user group 127 Jul 14 15:18 poe_dados.pl
unix#
unix#poe_dados.pl <- envia dados ao pipe
unix#ls -la
total 8
drwxr-xr-x 2 user group 512 Jul 15 10:09 .
drwxr-xr-x 7 user group 1024 Jul 15 10:09 ..
-rwxr-xr-x 1 user gtoup 144 Jul 14 15:19 le_dados.pl
prw-r--r-- 1 user group 0 Jul 14 15:25 novo_pipe
-rwxr-xr-x 1 user group 127 Jul 14 15:18 poe_dados.pl
-rw-r--r-- 1 forster oper 380000 Jul 15 15:09 saida
---------->>>>Note a criacao do arquivo "saida" ....
unix# cat saida | wc -l
unix# 10000
.... com as 10000 linhas enviadas por poe_dados.pl ao pipe, e lidas por
le_dados.pl.
Assim como no exemplo acima os dados foram enviados por poe_dados.pl e
lidos por le_dados.pl, os dados podem ser enviados pelo syslogd e lidos
por um simples script como o colocado no exemplo.
**********************************************************************************************
Scripts para Unix
Colaboracao: Jose Vicente Machado Filho
No endereco http://www.shavenferret.com/scripts podem ser encontrados
diversos scripts para ajudar administradores de Websites baseados no
sistema operacional Unix. Todos os scripts sao gratuitos e disponibilizados
sem restricao de uso.
O site e bem organizado e disponibiliza listas para divulgacao de
novos scripts e novas versoes dos ja existentes.
**********************************************************
O comando date e o ano 2000
Como ja havia dito antes, a lista Dicas-L e totalmente automatizada
(menos a criacao das dicas, e claro). Desta forma, recentemente, como
mereco, tirei uns 20 dias de ferias e ninguem notou. As mensagens
continuaram chegando regularmente, nao e?
Cada dica que escrevo e colocada em um arquivo contendo a data
do dia em que ira circular. Esta mensagem por exemplo, esta contida
em um arquivo chamado 990115.doc.
Mas ai vem o ano 2000. Voces notaram que somente uso dois digitos
para o ano. Desta forma, provavelmente no ano 2000 a lista Dicas-L
entrariam na lista dos servicos inoperantes, causando transtornos
e preocupacao em muita gente (certo? :-)
Para resolver isto, basta mudar o script de automatizacao da lista.
Hoje eu obtenho o nome do arquivo a partir da data com o seguinte
comando:
TIP_FILE=`date +%y%m%d`
A variavel $TIP_FILE e usada em varios pontos do script
para identificar os diversos arquivos gerados.
Para resolver o problema, basta substituir:
TIP_FILE=`date +%Y%j`
Desta forma, a variavel $TIP_FILE, passara a representar o ano
com 4 digitos e a data passara a ser representada no formato Juliano.
No dia 1 de janeiro, a variavel TIP_FILE assumira o valor 1999001.
A adocao do formato juliano nao e realmente necessaria. Estou fazendo
isto apenas por conveniencia, pois em breve pretendo voltar a circular
mensagens na Dicas-L tambem aos sabados e domingos, o que parei de
fazer ha alguns meses por falta de tempo.
E pronto, esta resolvido o problema do ano 2000 (ao menos para a
Dicas-L :-)
Uma observacao final. Estes valores (%j, %Y, etc,) podem variar de
sistema para sistema. A solucao apresentada obedece a sintaxe do
comando date para sistemas Solaris.
**********************************************************
Acho q eh isso q vc quer !!!!!!
#!/bin/sh
while [ "$#" -gt "0" ]; do
case $1 in
-help) help;;
-v) VERBOSE=true;;
-a) A=true;;
*) echo "Uso: $0 -v -a -help"; exit 1;;
esac
shift
done
~
t+
Brito
Assunto: (linux-br) Shell Script
Oi pessoal,
estou criando um script, mas estou tendo dificuldades num certo momento,
da tomada de decisão.
Vou me explicar melhor: quando o script é rodado sem nenhum parâmetro,
deve mostrar uma mensagem de erro ao usuário, que ao mesmo tempo,
explica o funcionamento do script. Algo assim:
$ script
Uso: script [file] ...
Estou usando o seguinte para fazer essa tomada de decisão:
if [ $1 = ];then
echo ""
echo " Errado!" (é claro que a mensagem não é esta :))
echo ""
else
analisa parâmetros e executa a função do script
Até aí tudo bem... quando executamos o script sem parâmetros, ele exibe
devidamente a mensagem de erro. Mas quando executamos o script com os
parâmetros, ele gera uma pequena mensagem de erro antes de executar os
comandos:
/usr/local/bin/script: [: parâmetro: unary operator expected
o mais estranho é que se eu tirar essa tomada de decisão, e criar um
script apenas com os comandos a serem executado, e executar este script
com os parâmetros, tudo funciona beleza...
será que alguém pode me ajudar?
********************************************************************************
> Como especificar o que o cat deve recolher, pois muito do que preciso
do
> HTML está com sinais de " " ou <> que ele não reconhece muito bem.
>
> Como pegar o texto em determinado local do arquivo ?, digamos depois
de
> certa palavra.
Caro LinuX,
O segredo está em expressões regulares no Perl, não vai dar para
contar
tudo que você pode fazer com RE( regular expressions) mas vou dar
alguns
exemplos que eu uso:
As vezes eu tenho um variável que possue a seguinte linha
RC0-DA0001-130200-022-A05 , e eu preciso saber a data desta linha,
lembre-se que eu não sei a data eu só sei que ela está sempre naquela
mesma posição. Então eu faço:
$linha=~/\w{2}\d-\w{2}\d{4}-(\d{6})-\d{3}-\w\d{2}/;
$data=$1;
Explicação, após o "~" começa a RE eu digo que a linha ou a expressào
tem que ter 2 letras e depois um dígito , logo depois um hífem seguido
de mais 2 letras , (então \w=qualquer letra e \d=qualquer dígito)o que
está entre chaves indica que "must be"tem que combinar o número extato
então não importas oque está escrito na linha inteira desde de que
tenha
uma combinação de caracteres que combinem com a minha máscara, agora o
que está entre parênteses será quardado na varaável $1 , se houvessem
mais parêntese seriam $2,$3,$4....estas variável são "read only" então
você tem que mudar para outra variável antes que aconteça outra RE.
Sugiro que você leia mais sobre RE , eu depois que saquei como elas
funcionam me ajudou pacas.
Qualquer dúvida mande um e-mail que eu te ajudo com o que eu souber.
[]'s
Marco.
********************************************************************************
mova ()
{
echo "mv ${i} ${nome}"
mv ${i} ${nome}
}
for i in *
do
tmp=`${i}`
nome=`echo ${tmp} | tr "[a-z]" "[A-Z]"`
if [ "${i}" != "${nome}" ]
then
mova
fi
done
> Assunto: [ano2001] (linux-br) Script
>
> Pessoal.... alguém sabe como fazer um script para renomear todos os
> arquivos
> de um diretório para minúsculas??
>
ou
for i in * ; do [ -f $i ] && mv -i $i `echo $i | tr '[A-Z]' '[a-z]'`;done;
********************************************************************************
SHELL PARA DAR KILL E PID'S
funcionou belezinha!
>
> Talvez isso funcione
> cat /tmp/PIDS_aplic|while read a b
> do
> kill -9 $a
> done
********************************************************************************
> Eu tenho um arquivo contendo o nome de todos os usuarios e queria criar um
> script para ler esse arquivo e executar o finger para cada usuario
for i in `cat arquivo`; do finger @$i; done
************************************************************************
De: Gustavo Roberto Rodrigues Gonçalves
Para: Linux
Assunto: Re: (linux-br) Bash Script
Data: 24 Feb 2003 11:38:47 -0300
Já encontrei o problema, nada que um pouco a mais de leitura não resolva .
Eu tinha que cercar o comando com apostrofos e não com aspas como eu tinha
feito
----- Original Message -----
From: "Gustavo Roberto Rodrigues Gonçalves"
To: "Linux"
Sent: Monday, February 24, 2003 10:59 AM
Subject: (linux-br) Bash Script
Ola pessoal , estou precisando fazer um script para o Iptables esta quase
todo pronto mais estou encalhado numa duvida
quando eu digito
echo $IPTABLES resto_do_comando ele interpreta $IPTABLES como qualquer coisa
e o mesmo não aparece dentro do arquivo que estou gerando . Tipo assim
echo $IPTABLES -lallaallalalalalalalal >> /home/teste/iptables
alguem sabe me dizer com fazer o shell jogar esse comando ???
************************************************************************
De: Anderson Lizardo
Para: Fabrício Carvalho de Matos
Cc: linux-br@bazar.conectiva.com.br
Assunto: Re: (linux-br) Criar script
Data: Thu, 22 May 2003 17:25:08 -0300 (ART)
Em Sábado, 17 de Maio de 2003 15:32, Fabrício Carvalho de Matos
escreveu:
> Gostaria da ajuda de vocês. Preciso criar um script que faça as
> seguintes operações:
> - Criar um arquivo
> - Gravar uma string dentro deste arquivo
Para estes dois, basta usar o "echo":
$ echo "String de texto" > arquivo.txt
Se o texto tiver várias linhas, é mais legível usar o "cat":
$ cat > arquivo.txt << "EOF"
linha 1
linha 2
linha 3
...
EOF
> - Enviar este arquivo para uma área de FTP (usando usuário e senha).
Aqui, você pode usar o "curl":
$ curl -T arquivo.txt ftp://login:senha@ftp.servidor.com/pasta/
Mais informações:
$ man echo cat curl
--
Anderson Lizardo
************************************************************************
************************************************************************
************************************************************************