Posts Tagged "script"

Script para verificar o Hardware em Linux

Certos de que algum dia vocês precisam de algum programa para saber a configuração do hardware de uma máquina linux. Aqui segue um script que auxilia nisso:

#!/bin/sh

# Script para verificar configurações do computador
# CPU (and cores)
# CPU speed
# Memory
# Hard disks
# OS version

echo "Kernel Version: "
uname -a | awk '{print $3}'
echo " "
echo "Distribution: "
head -n1 /etc/issue
echo " "
echo "All partitions registered: "
cat /proc/partitions
echo " "
echo "Total disk space: "
fdisk -l | grep "Disk /dev"
echo " "
echo "Total RAM: "
free -h | grep "Mem:" | awk '{print $2}'
echo " "
echo "CPU info: "
cat /proc/cpuinfo | grep "model name" | head -n1 | awk '{print $4,$5,$6,$10}'
echo " "
echo "VGA device: "
lspci | grep "VGA" | awk '{print $5,$6,$7,$8,$9}'

 

[Shell] Tipos de controle e testes

Uma das principais dificuldades para quem trabalha com Shell Script no Linux é a quantidade de tipos de controles e testes nas estruturas de loop e repetição. Segue uma lista dos principais:

Comparações entre números

 
  -eq : igual a
  -ne : diferente de
  -gt : maior que
  -ge : maior ou igual a
  -lt : menor que
  -le : menor ou igual a
  -a : AND binário (bit a bit)
  -o : OR binário (bit a bit)

Comparações entre strings usando []

 
  = : igual a
  != : diferente de
  -z : string de tamanho zero

Comparações entre strings usando Shell scripts

 
  = : maior ou igual a (lexicográfico)

Associações entre condições

 
  && : AND lógico
  || : OR lógico

Os operadores de teste em arquivos 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 : 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 : o stick bit está habilitado
    x : a entrada pode ser executada
    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)

Segue um exemplo:

 
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

 

Script para inclusão de Cabeçalho GPL

O script a seguir inclui o cabeçalho GPL v2 em códigos .java. É legal, pois facilita e muito o trabalho do desenvolvedor que está transferindo projetos para o software livre, como é o caso do SIEP Gerencial.

Agradecimento ao aluno Maxwell Queiroz pela ajuda, porém acho que ele deve estudar mais…. 😀

#!/bin/bash
#Autor Anderson Moreira
#Autor Maxwell Queiroz

#Funcao que insere os termos de GNU no arquivo.
function insereGNU() {
sed  '1i\/*
1i\Copyright (C) 2010 - Secretaria de Educação Profissional e Tecnológica
1i\Author: '"$2"' - siep@renapi.org
1i\
1i\This program is free software: you can redistribute it and/or modify
1i\it under the terms of the GNU General Public License as published by
1i\the Free Software Foundation, either version 3 of the License, or
1i\(at your option) any later version.
1i\
1i\This program is distributed in the hope that it will be useful,
1i\but WITHOUT ANY WARRANTY; without even the implied warranty of
1i\MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1i\GNU General Public License for more details.
1i\
1i\You should have received a copy of the GNU General Public License
1i\along with this program.  If not, see <http://www.gnu.org/licenses/>.
1i\
1i\*/' $1 > $1.tmp
}

#Funcao que gera a lista de arquivos a serem modificados.
function geraLista() {

IFStmp=$IFS
IFS=":"

if [ -w `pwd` ]
then
find `pwd` -type f -iname '*.java' > arqLista.txt.tmp
sed '/arqLista.txt/d
/arqErro.txt/d
/convGNU.sh/d' arqLista.txt.tmp > arqLista.txt
rm arqLista.txt.tmp
else
echo "-----------------------------------------------------------------------"
echo "                              ERRO!                                    "
echo "A lista de arquivos não pode ser gerada no diretorio atual, verifique  "
echo "os privilegios de escrita.                                             "
echo "-----------------------------------------------------------------------"
exit
fi

IFS=$IFStmp

}

#Funcao que testa a escrita em um determinado arquivo.
testaEscrita() {
if [ ! -w $1 ]
then
if [ ! -e arqErro.txt ]
then
echo "-----------------------------------------------------------------------" > arqErro.txt
echo "Erro de acesso em alguns arquivos!                     " >> arqErro.txt
echo "Verifique suas permissoes de acesso/escrita nos arquivos abaixo.     " >> arqErro.txt
echo "-----------------------------------------------------------------------" >> arqErro.txt
echo "$1"                                          >> arqErro.txt
else
echo "$1"                                          >> arqErro.txt
fi

flagErro=1
flagArq=1
flagErroTest=1

fi
}

#Funcao que testa se ja foi inserido os termos GNU no arquivo.
testaGNU() {
tGNU=`grep "GNU General Public License"  $1 | wc -l`
if [ $tGNU -ge 1 ]
then
flagArq=1
fi
}

#Funcao que limpa logs.
limpaLogs() {
if [ -e arqLista.txt ]
then
rm -f arqLista.txt
fi

if [ -e arqErro.txt ]
then
rm -f arqErro.txt
fi
}

############################### < Início do corpo do script. > ###############################

#Chamada da funcao que limpa possiveis logs existentes.
limpaLogs

#Chamada da funcao que gera a lista de arquivos.
geraLista

echo "-----------------------------------------------------------------------"
echo "                             ATENCAO!!!                                "
echo "Este script insere um cabecalho com os termos GNU em TODOS os arquivos "
echo "\".JAVA\" deste diretorio \"`pwd`\" e seus sub-diretorios.         "
echo "-----------------------------------------------------------------------"

#Leitura dos dados do autor.
read -p "Digite o nome do Instituto: " nome
#read -p "Digite seu e-mail: " email

#Estrutura de repeticao que incrementa o termo da GNU nos arquivos.
IFStmp=$IFS
IFS=$( echo -en "\n\b" )
flagErroTest=0

for k in `cat arqLista.txt`
do
flagArq=0
flagErro=0
testaEscrita "$k"
testaGNU "$k"
if [ $flagArq == 1 ]
then
continue
else
#     insereGNU "$k" "$nome" "$email"
insereGNU "$k" "$nome"
rm $k
mv $k.tmp $k
fi
done

IFS=$IFStmp

#Condicional que avisa ao usuario se houve algum erro.
if [ $flagErroTest == 1 ]
then
echo "-----------------------------------------------------------------------"
echo "Feito! Entretanto, houve um ou mais erros de acesso em seus arquivos.  "
echo "Verifique o arquivo \"arqErro.txt\" no diretorio atual.                "
echo "-----------------------------------------------------------------------"
fi

echo "Feito!"
sleep 3

############################### Fim do corpo do script  ##################################

Scripts para verificação da SWAP

Pessoal,

Como tinha dito em sala de aula o uso da swap em sistema Linux é relativo, já que muitas vezes os atuais sistemas computacionais usam muito pouco essa área reservada. Aqui segue o script feito em sala de aula.

O experimento é bem simples:

Em um shell do Linux crie um script shell com o nome disco.sh e coloque o seguinte conteúdo:

#!/bin/bash
dd if=/dev/zero of=disco.dump bs=1024 count=1024000

Salve o arquivo. Crie um novo script shell com o nome memoria.sh com os seguintes comandos:

 #!/bin/bash

##################################################
#
#   Script para verificar se o computador usa a SWAP
#   Autor: Anderson L. S. Moreira (anderson@rtsystems.org)
#   Data: 12 de fevereiro de 2007
#
##################################################

 ANO=`date +%Y`
 MES=`date +%m`
 DIA=`date +%d`
 HORA=`date +%H`
 MIN=`date +%M`

 DATACOMPLETA=""$ANO""$MES""$DIA"-"$HORA":"$MIN""

 USUARIO=anderson

 FREEARG='-m' # '-m' para ver em MB, -k para ver em KB e -GB para ver em GB. Prefira -m.

 SWAP_USADO=`free $FREEARG | grep Swap | tr -s ' ' ',' | cut -d "," -f 3`

 MEM_USADA=`free $FREEARG | grep Mem | tr -s ' ' ',' | cut -d "," -f 3`

 MEM_LIVRE=`free $FREEARG | grep Mem | tr -s ' ' ',' | cut -d "," -f 4`

 CACHE=`free $FREEARG | grep Mem | tr -s ' ' ',' | cut -d "," -f 7`

 LIVRE_CACHE=`expr $MEM_LIVRE + $CACHE`

 PSTOTAL=`ps ax | wc -l`

 PSUSUARIO=`ps aux | grep ^$USUARIO | wc -l`

 echo ""$DATACOMPLETA": Ps: "$PSTOTAL". Ps $USUARIO: `expr "$PSUSUARIO" - 1`. Mem usada: $MEM_USADA. Mem livre: $MEM_LIVRE. Cache+mem livre: $LIVRE_CACHE. Swap usado: "$SWAP_USADO"MB" >> /tmp/swap.txt

O experimento pode ser feito de duas maneiras:

1) Executando o script memoria.sh sozinho e repetindo diversas vezes. Pode ser colocado no crontab do sistema através do comando:

crontab -l
00-59/1 * * * * /opt/memoria.sh

Lembrando que o comando acima executa o script a cada 1 minuto.

2) Execute os scripts em paralelo disco.sh e memoria.sh e veja o que acontece com a saída swap.txt.

cd /opt
./disco.sh &
./memoria.sh

É bom deixar claro que isso é um teste simples. Em sistemas de banco de dados, com grande tráfego de dados, por exemplo vemos que o uso da swap é constantemente acessada. então depende da aplicação para termos ou não uso da swap.
Obs.: não esqueçam de dar permissão de execução aos scripts depois de criados.