Para manter uma lista “organizada” para mim, meus colegas de trabalho e quem mais precisar, segue uma lista simples com alguns comandos (eventualmente eu adiciono mais alguma coisa, mas vai isso mesmo agora):

prstat -a -> lembra o “top” do Linux.

vmstat 1 -> mostra status da memória e atualiza a cada 1 segundo. Sem o “1″ apenas mostra o status e finaliza.

iostat 1 -> mostra status de I/O a e atualiza a cada 1 segundo.

mpstat 1 -> mostra status de cada cpu e atualiza a cada 1 segundo.

/usr/ucb/ps auxwww|grep 15251 -> mostra “todo” o comando cujo PID é 15251. É necessário digitar o PATH completo (ou mudar a ordem do PATH da máquina) pois este é outro ps que vem nos Solaris. Não sabia que tinha outro ps? Dê uma passeada em /usr/ucb ou em /usr/xpg4/bin e veja o que mais tem repetido mas com algumas funcionalidades diferentes :)

psrinfo -v -> mostra o processador instalado e velocidade.

prtvtoc /dev/dsk/c0d0s0 -> mostra informações sobre partições do disco.

/usr/sbin/prtconf -> mostra informações sobre a máquina (incluindo memória instalada).

kstat -c net|grep net -> mostra interfaces de rede disponíveis.

prtdiag -> mostra algumas informações do sistema.

Como sei que esta pode ser uma dúvida para mais pessoas, resolvi publicar este mini artigo com o resumo da conversa.

Pergunta: tem algum comando rápido e fácil de unix pra dividir um arquivo em vários?
Resposta: split
Resposta: split -b 100M arquivo_origem destino
Resposta: vai quebrar o arquivo_origem em arquivos de 100 mbytes e o prefixo do nome será “destino”
Pergunta: tem como ser pela quantidade de linhas?
Resposta: split -l 100 arquivo_origem destino
Resposta: vai quebrar em arquivos de 100 linhas

Acho que pelo resumo do diálogo já é possível que se tenha uma ideia básica do funcionamento do comando split. Caso tenha mais dúvidas, consulte o help:

$ split --help

Usage: split [OPTION] [INPUT [PREFIX]]

Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default

size is 1000 lines, and default PREFIX is `x'.  With no INPUT, or when INPUT

is -, read standard input.

Mandatory arguments to long options are mandatory for short options too.

-a, --suffix-length=N   use suffixes of length N (default 2)

-b, --bytes=SIZE        put SIZE bytes per output file

-C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file

-d, --numeric-suffixes  use numeric suffixes instead of alphabetic

-l, --lines=NUMBER      put NUMBER lines per output file

--verbose           print a diagnostic to standard error just

before each output file is opened

--help     display this help and exit

--version  output version information and exit

SIZE may have a multiplier suffix:

b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,

GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.

Todos os exemplos daqui podem ser testados bastando apenas salvar o arquivo em formato ASCII (pode-se usar qualquer editor de texto para isso, vi ou emacs por exemplo) e dar a permissão de execução ao arquivo do script (com chmod u+x nome-do-script).

A essência da programação em scripts pode ser resumida em saber lidar bem com pipes (se pronuncia páipes), redirecionamentos e pouco mais que uma dúzia de comandos.

Eu pretendo com este (futuro) conjunto de textos passar um exemplo simples e explicar os detalhes dele seja novos comandos ou mesmo o porque de um redirecionamento ao invés de um pipe. Além disso, pretendo explicar alguns conceitos como por exemplo como fazer um laço num script e etc.

O uso de Pipes No primeiro exemplo, vamos ver um script que simplesmente conta quantos são os usuários cadastrados no sistema.

#!/bin/bash
cat /etc/passwd |wc -l

A primeira linha (#!/bin/bash) apenas informa ao sistema qual shell usar e a segunda, lê o arquivo com informações do usuário e repassa estas informações por pipe para o comando wc -l, que apenas conta o número de linhas recebidas pela entrada padrão (stdin).

O pipe nada mais é que o símbolo | e este faz com que tudo o que for saída padrão (stdout) do comando antes do pipe seja repassado para a entrada padrão do comando após o pipe. O comando cat neste exemplo irá direcionar o conteúdo do arquivo /etc/passwd para sua saída padrão (este arquivo nada mais é do que o banco de dados de usuários de um sistema Unix e cada usuário é representado por exatamente uma linha deste arquivo). Sabendo que cada usuário ocupa uma linha, basta contarmos quantas linhas tem este arquivo para sabermos quantos usuários o sistema possui. É aí que o comando wc entra. Com o parâmetro -l, wc conta o número de linhas recebidas resultando neste caso no número de usuários do sistema. Simples não ?

Após salvarmos o arquivo (que vou chamar de script.sh), damos a permissão de execução para o arquivo com chmod u+x script.sh e o executamos com ./script.sh. A saída dele deve ser apenas um número, como 35.

Aqui começam os problemas: você sabe que existem 35 usuários no sistema, mas e o seu chefe (aquele mesmo que tem dificuldade até para mudar o papel de parede daquele sistema operacional), ele vai saber o que este número sem lógica significa ?

Expansão de comandos Agora que já vimos como usar pipes, vamos começar a deixar nossos scripts mais amigáveis.

#!/bin/bash
echo “Existem `cat /etc/passwd |wc -l` usuarios no sistema”

Neste exemplo, usamos o comando echo que simplesmente irá ecoar tudo o que estiver entre as aspas para a saída padrão mas, antes disso, o bash irá executar os comandos entre as crases e retornar para o echo a saída do comando. O echo vai receber entre as aspas algo como Existem 35 usuarios no sistema e irá ecoar isso (agora o seu chefe vai saber o que o seu script faz !).

Trabalhando com variáveis Nosso pequeno script até agora apenas executa comandos, ele não armazena informação alguma. Se precisarmos do número de usuários cadastrados no sistema em algum outro momento, teremos que executar os comandos novamente ou podemos armazenar o resultado dele em uma variável:

#!/bin/bash
tmp=`cat /etc/passwd | wc -l`
echo “Existem $tmp usuarios no sistema”

No exemplo anterior, armazenamos o número de usuários do sistema numa variável chamada tmp e a passamos como parâmetro para o echo (o shell expande as variáveis antes de executar o comando, neste exemplo a variável foi tratada pelo shell como se o próprio comando entre crases tivesse sido executado novamente, mas isto não foi preciso pois o shell “lembrou” do resultado da última execução). O shell sabe que é uma variável porque colocamos um $ antes do nome dela.

Trabalhando com laços para (for) Podemos incrementar nosso script fazendo, por exemplo, ele contar quantas vezes um usuário conectou ao sistema. Neste caso, usaremos o comando last, que retorna todos os logins que obtiveram sucesso no sistema desde a instalação do mesmo (ou desde que o log foi rotacionado pela última vez) e o comando cut, que serve para cortar parte de uma linha:

#!/bin/bash
for user in `cat /etc/passwd|cut -d “:” -f 1`;do
cont=`last|grep $user|wc -l`
echo “usuario $user conectou $cont vezes”
done

Explicando com detalhes: o cut recebe cada linha do comando cat e retorna apenas o primeiro campo (-f 1) usando “:” como separador de campos (se você executar apenas cat /etc/passwd poderá observar que o primeiro campo corresponder ao nome dos usuários no sistema). O for construído desta maneira, irá montar um vetor (referenciado pela variável user ) onde cada posição contém o nome de um usuário do sistema. Além disso, cada passo do laço será exatamente o nome de um usuário.

Dentro do laço, a variável count receberá a saída da execução do comando last (para obter uma lista de todo mundo que se logou no sistema) passando a saída por pipe para grep (onde iremos filtrar para mostrar apenas as linhas com o usu&aaute;rio user) e finalmente irá repassar, também por pipe, para wc (onde iremos contar quantas linhas aparece o nome do usuário, ou seja, quantas vezes ele se logou no sistema).

Ainda no laço, iremos ecoar o nome do usuário que estamos lendo da lista naquele momento e a valor atual de cont. Para finalizar o laço, usamos done.i

Testes de condições (if / else) No script anterior, vimos que vários usuários se conectaram 0 vezes ao sistema. A maioria deles é usuário do sistema que nunca terá login algum (se tiver, é bom se analisar o motivo, pode ser alguma falha de segurança sendo explorada).

Mas e se eu não quiser mostrar quem nunca se conectou ? Poderíamos apenas fazer um teste para ver se a variável cont esta com valor 0 e, se não estiver, imprimimos a mensagem.

#!/bin/bash
for user in `cat /etc/passwd|cut -d “:” -f 1`;do
cont=`last|grep $user|wc -l`
if [ $cont -ne 0 ]; then
echo “usuario $user conectou $cont vezes”
fi
done

Neste script, adicionamos o teste se (if) onde verificamos se a variável cont é diferente ( -ne, not equal) de zero. Se for diferente, o script executa o bloco entre o if e o fi (fi finaliza um bloco if) e a mensagem informando o número de logins do usuário será mostrada.

Além disso, poderíamos colocar uma mensagem informando que o usuário nunca se logou ao sistema (ao invés de informar que ele se logou zero vezes).

#!/bin/bash
for user in `cat /etc/passwd|cut -d “:” -f 1`;do
cont=`last|grep $user|wc -l`
if [ $cont -eq 0 ]; then
echo “usuario $user nunca conectou ao sistema”
else
echo “usuario $user conectou $cont vezes”
fi
done

Neste exemplo, mudamos o teste para se igual (-eq, equal) a zero, então mostre a mensagem e adicionamos um senão ( else), mostre outra mensagem.