As i was discussing in a previous article of mine, i use jmap to export heap statistics on a periodical basis, while i run my performance tests. The biggest disadvantage of jmap is that it does not have any timestamp logging enabled.

Today i found myself badly needing a timestamp, in order to better track and isolate my “heap loosers” So there i was, back to regular expressions, on the fly text editing, sed, awk, greps…all those beloved friends.

Well, in the end, i managed to figure something out, and it looks like this:

JMAP_TIMESTAMP=`date +%H-%M-%S`
                ssh ${DOMAIN_SERVER} “sudo -u glassfish /bin/bash -c ‘${JAVA_BIN}jmap -histo ${glassfish_pid}’” | egrep  -i -e ‘\[[I,B,C]+’  -e ‘java.util.Hash’ -e ‘java.util.Vector’ -e ‘Klass’ | sed ‘/[0-9]/s/$/’,”${JMAP_TIMESTAMP}”‘/’ >> /tmp/filtered.log

Where:

JMAP_TIMESTAMP is the time of the system, in the HH-MM-SS format, and is used as a variable when replacing on the fly

DOMAIN_SERVER is the server name where the Glassfish Server is running

JAVA_BIN is a variable containing the path to the JAVA BIN folder on the server

glassfish_pid is a variable that contains the pid of the running application server

The piece of code above, will strip the white spaces, the “:”, and will add the timestamps at the end of each line.

I myself run this piece of code in a while loop every 5 seconds, and use the “filtered.log” file for appending the information that i will later use for data importing and transformation

Hope it will be of use to you guys

Cheers, gluhwein and Christmas Market is waiting for me

Alex

Tiếp theo series filter trong unix, lần này tôi muốn đề cập tới một filter nữa rất hữu dụng và cũng rất thông dụng, đó là grep và egrep – một mở rộng của nó (fgrep bạn có thể tự tìm hiểu thêm). Trước hết, 2 filter trên dùng để làm gì ? Chúng được dùng để lọc ra các dòng thỏa mãn một mẫu (partern) mà bạn chỉ định, ví dụ như số điện thoại, địa chỉ IP, tên, …

Hai filter này thực ra có thể đồng nhất được, tức là bạn có thể dùng egrep nếu thêm tùy chọn -e vào trong câu lệnh grep. Cấu trúc lệnh grep:

grep [OPTIONS] PATTERN [FILE...]

Các option thông dụng, bạn có thể gặp và sử dụng:

• -f : thay vì việc bạn chỉ ra một partern dài, bạn có thể chỉ ra file chứa partern đó
• -i : bỏ qua mọi khác biệt về chữ hoa/thường giữa partern và nội dung trong file đầu vào
• -v : thực hiện tìm các dòng không chứa partern được đưa ra
• -w : chỉ tìm những dòng mà có từ khớp toàn bộ với mẫu tìm kiếm
• -x : tìm dòng mà toàn bộ dòng khớp với mẫu tìm kiếm
• -c (–count ): Thay vì liệt kê các dòng khớp, nó cho ra số dòng khớp, nếu sử dụng cùng với tùy chọn -v thì nó sẽ đếm số dòng không khớp
• -m NUM hoặc –max-count=NUM : Khi khớp được NUM dòng, nó sẽ không tìm tiếp trong file nữa
• -q hoặc –quiet, –silent : Không in ra bất cứ thứ gì ở standard output, trả về 0 khi match được bất cứ môt kết quả nào. Khi bạn chạy một shell thì điều này sẽ cần dùng đến. Nếu không thu được kết quả nào, sẽ trả về một lỗi error (có thể sẽ được gửi tới stder ).
• -H hoặc –with-filename : in các dòng match cùng với tên file chứa nó (trong trường hợp tìm trên nhiều file). Tùy chọn này là mặc định, bạn không cần chỉ ra nó.
• -h, hoặc –no-filename : không thêm tên các file ứng với các dòng match.

I always get confused about various flavors of grep. Here’s a summary to shine some light: (man grep to know more!)

• egrep or grep -E (in linux only) is extended grep where additional regular expression metacharacters have been added like +, ?, | and ()
• fgrep or grep -F (in linux only) is fixed or fast grep and behaves as grep but does not recognize any regular expression metacharacters as being special.

For grepping line-by-line in a file filename, I often find these very useful

Match pattern1 OR pattern2 in the same line:
$ grep -E 'pattern1|pattern2' filename

Match pattern1 AND pattern2 in the same line:
$ grep -E 'pattern1.*pattern2' filename
The above command searches for pattern1 followed by pattern2. If the order does not matter or you want to search them in either order, then use the follwoing
$ grep -E 'pattern1.*pattern2|pattern2.*pattern1' filename
The pipe enables the OR search which we saw earlier. Another option for this situation (i.e., AND search when the order is not important):
$ grep -E 'pattern1' | grep -E 'pattern2'
which basically greps the STDOUT of the first grep.

Match pattern1 AND pattern2, but NOT pattern3 in the same line:
$ grep -E 'pattern1.*pattern2' filename | grep -Ev 'pattern3'
when the order of the first two patterns is important. When that order is NOT important:
$ grep -E 'pattern1' filename | grep -E 'pattern2' | grep -Ev 'pattern3'

Match pattern1 OR pattern2, but NOT pattern3 in the same line:
$ grep -E 'pattern1|pattern2' filename | grep -Ev 'pattern3'

N.B. (1) grep -E may be replaced by egrep.  I used grep -E everywhere in this post assuming a general case of regular expressions as patterns. Lowercase -e is also used for regex, but this is more “basic” than -E which supports “extended” regex, e.g. regular expression metacharacters like +, ?, | and (). (2) The -v flag is for non-matching grep.

Dado un nombre de archivo, o una parte del mismo, encontar en un listado de archivos, con su path relativo(o absoluto), la linea o lineas que coincidan, pero solo en la parte de nombre del archivo y no en el nombre del directorio.

Genero un listado de archivos que me interesan, digamos una especie de indice. Para asegurame que la salida del comando find sólo contenga archivos, le paso el parámetro -type f. En mi caso, también quiero evitar mostar en la salida de find los archivos del directorio .git(o .svn), entonces entubo el comando egrep con la expresión -v ‘.git|.svn’. El parámetro -v invierte el comportamiento normal de egrep. Esto es, en lugar de filtrar y dejar pasar lo que coincide según la expresión regular, deja pasar todo menos lo que coincide.

Bien, creo el indice de archivos:

fellini:~/dev/proyecto_millonario $ find . -type f | egrep -v '.git|.svn' > lista_de_archivos

Ahora para obtener el path, en este caso relativo, del archivo que estoy buscando uso este comando, donde cadena es parte del nombre del archivo:

fellini:~/dev/proyecto_millonario $ cat lista_de_archivos | egrep -i '/.*cadena[^/]+$'

ls -l  | awk ‘{ system(“chown -R “$3″ “$8) }’

//cuidado com directorios que contenham espaços doens’t work with spaces ;

find /home/ -uid 0 -exec ls -l \{\} \;

fgrep ‘gold’ /var/log/ -R | grep -i something

or regexp style search
egrep ‘(err|fail|warning)’ /var/log/* > `date +%F`.txt

ls -l  | sed -e ’s/andre/netcrash/gi’

#!/usr/bin/perl

print “hello\n”;
$dir=”/home/andre”;
if ( (!(-d $dir.”/Maildir”)) ){
`/usr/bin/maildirmake.maildrop $dir”/Maildir”`;

}

bash
[03:42:08]andre@garden:~$ for i in `seq 10`; do echo $i ; done;

Haven’t been using cut that mutch but, also a good weapon of choice.

Simple things that evolve to more complex tools

- Garçom! Traz um “chops” e dois “pastel”. O meu amigo hoje não vai beber por que ele finalmente está sendo apresentado a um verdadeiro sistema operacional e ainda tem muita coisa a aprender!
- E então, amigo, tá entendendo tudo que te expliquei até agora?
- Entendendo eu tô, mas não vi nada prático nisso…
- Calma rapaz, o que te falei até agora, serve como base ao que há de vir daqui pra frente. Vamos usar estas ferramentas que vimos para montar programas estruturados, que o Shell permite. Você verá porque até na TV já teve programa chamado “O Shell é o Limite”.
- Para começar vamos falar dos comandos da família grep.
- grep? Não conheço nenhum termo em inglês com este nome…
- É claro, grep é um acrônimo Global Regular Expression Print, que usa expressões regulares para pesquisar a ocorrência de cadeias de caracteres na entrada definida (se bem que há uma lenda sobre como este comando foi nomeado: no editor de textos “ed”, o avô do “vim”, o comando usado para buscas era g/_expressao regular_/p, ou no inglês g/_re_/p.). Por falar em expressões regulares (ou regexp), o Aurélio Marinho Jargas tem todas as dicas em sua página (inclusive tutorias) que abordam o tema. Se você está mesmo a fim de aprender a programar em Shell, Perl, Python, … Acho bom você ler estes artigos para te ajudar no que está para vir.

Eu fico com o grep, você com a gripe

Esse negócio de gripe é brincadeira! É só um pretexto para pedir umas caipirinhas. Mas voltando à vaca fria, eu te falei que o grep procura cadeia de caracteres dentro de uma entrada definida, mas o que vem a ser uma “entrada definida”? Bem, existem várias formas de definir a entrada do comando grep. Vejamos: Pesquisando em um arquivo:

Pesquisando em vários arquivos:

Pesquisando na saida de comando:

No 1º exemplo, o mais simples, procurei a palavra rafael em qualquer lugar do arquivo /etc/passwd. Se quisesse procurá-la como um login name, isto é, somente no início dos registros deste arquivo, eu deveria fazer:

E para que serve este circunflexo e os apóstrofos, você vai me perguntar. O circunflexo (^), se você tivesse lido os artigos anteriores sobre expressões regulares que te falei, saberia que servem para limitar a pesquisa ao início de cada linha, e os apóstrofos (') servem para o Shell não interpretar este circunflexo, deixando-o passar incólume para o comando grep.

Olha que legal! O grep aceita como entrada, a saída de outro comando redirecionado por um pipe (isto é muito comum em Shell e é um tremendo acelerador de execução de comando já que atua como se a saída de um programa fosse guardada em disco e o segundo programa lesse este arquivo gerado), desta forma, no 3º exemplo, o comando who listou as pessoas “logadas” na mesma máquina que você (não se esqueça jamais: o Linux é multiusuário) e o grep foi usado para verificar se o Pelegrino estava trabalhando ou “coçando”.

A família grep

Este comando grep é muito conhecido, pois é usado com muita freqüência, o que muitas pessoas desconhecem é que existem três comandos na família grep, que são:

• grep
• egrep
• fgrep

A principais características diferenciais entre os 3 são:

• O grep pode ou não usar expressões regulares simples, porém no caso de não usá-las, o fgrep é melhor, por ser mais rápido;
• O egrep (“e” de extended, extendido) é muito poderoso no uso de expressões regulares. Por ser o mais lento da família, só deve ser usado quando for necessária a elaboração de uma expressão regular não aceita pelo grep;
• O fgrep (“f” de fast, rápido, ou de “file”, arquivo) como o nome diz é o rapidinho da família, executa o serviço de forma muito veloz (por vezes é cerca de 30% mais veloz que o grep e 50% mais que o egrep), porém não permite o uso de expressões regulares na pesquisa.

Tudo que foi dito acima sobre velocidade, só se aplica à família de comandos grep do Unix. No Linux o grep é sempre mais veloz, já que os outros dois (fgrep e egrep) são scripts em Shell que chamam o primeiro e, já vou adiantando, não gosto nem um pouquinho desta solução.

- Agora que você já conhece as diferenças entre os membros da família, me diga: o que você acha dos três exemplos que eu dei antes das explicações?
- Eu achei que o fgrep resolveria o teu problema de forma mais veloz do que o grep.
- Perfeito! Tô vendo que você está atento! Está entendendo tudo que estou te explicando! Então vamos ver mais exemplos para clarear de vez as diferenças de uso dos membros da família.
Exemplos

Eu sei que em um arquivo existe um texto falando sobre Linux só não tenho certeza se está escrito com L maiúsculo ou l minúsculo. Posso fazer de duas formas:

ou

No primeiro caso, a expressão regular complexa "(Linux | linux)" usa os parênteses para agrupar as opções e a barra vertical (|) como um “ou” lógico, isto é, estou procurando Linux ou linux.

No segundo, a expressão regular [Ll]inux significa: começado por L ou l seguido de inux. Por esta expressão ser mais simples, o grep consegue resolvê-la, portanto acho melhor usar a segunda forma, já que o egrep tornaria a pesquisa mais lenta.

Outro exemplo. Para listar todos os subdiretórios do diretório corrente, basta:

No exemplo que acabamos de ver, o circunflexo (^) serviu para limitar a pesquisa à primeira posição da saída do ls longo. Os apóstrofos foram colocados para o Shell não “ver” o circunflexo (^).

Vamos ver mais um. Sabemos que as quatro primeiras posições possíveis de um ls -l de um arquivo comum (arquivo comum! Não é diretório, nem link, nem …) devem ser:

Assim sendo, para descobrir todos os arquivos executáveis em um determinado diretório eu deveria fazer:

Onde novamente usamos o circunflexo (^) para limitar a pesquisa ao início de cada linha, então as linhas listadas serão as que começam por um traço (-), seguido de qualquer coisa (o ponto quando usado como uma expressão regular significa qualquer coisa), novamente seguido de qualquer coisa, vindo a seguir um x ou um s.

Obteríamos o mesmo resultado se fizéssemos:

e agilizaríamos a pesquisa.

Vamos Montar uma “cdteca”

Vamos começar a desenvolver programas, acho que a montagem de um banco de dados de músicas é bacana para efeito didático (e útil nesses tempos de downloads de mp3 e “queimadores” de CDs). Não se esqueça que, da mesma forma que vamos desenvolver um monte de programas para organizar os seus CDs de música, com pequenas adaptações, você pode fazer o mesmo com os CDs de software que vêm com a Linux Magazine e outros que você compra ou queima, disponibilizando este banco de software para todos que trabalham com você (o Linux é multiusuário, e como tal deve ser explorado), desta forma ganhando muitos pontos com seu adorado chefe.

- Péra ai! De onde eu vou receber os dados dos CDs?
- Inicialmente, vou lhe mostrar como o seu programa pode receber parâmetros de quem o estiver executando e em breve, ensinarei a ler os dados pela tela ou de um arquivo.

Passando parâmetros

O layout do arquivo musicas será o seguinte:

nome do álbum^intérprete1~nome da música1:..:intérprete~nome da música

isto é, o nome do álbum será separado por um circunflexo (^) do resto do registro, que é formado por diversos grupos compostos pelo intérprete de cada música do CD e a respectiva música interpretada. Estes grupos são separados entre si por dois-pontos (:) e internamente, o intérprete será separado por um til (~) do nome da música.

Eu quero escrever um programa que chamado musinc, que incluirá registros no meu arquivo musicas. Eu passarei o conteúdo de cada álbum como parâmetro na chamada do programa fazendo assim:

Desta forma o programa musinc estará recebendo os dados de cada álbum como se fosse uma variável. A única diferença entre um parâmetro recebido e uma variável é que os primeiros recebem nomes numéricos (nome numérico fica muito esquisito, né? O que quis dizer é que seus nomes são formados por um e somente um algarismo), isto é $1, $2, $3, ..., $9. Vamos, antes de tudo, fazer um teste:

Exemplos

Vamos executá-lo:

Ops! Esqueci-me de torná-lo executável. Vou fazê-lo de forma a permitir que todos possam executá-lo e em seguida vou testá-lo:

Repare que a palavra testar, que seria o quarto parâmetro, não foi listada. Isto deu-se justamente porque o programa teste só listava os três primeiros parâmetros. Vamos executá-lo de outra forma:

As aspas não deixaram o Shell ver o espaço em branco entre as palavras e considerou-as um único parâmetro.

Macetes paramétricos

Já que estamos falando em passagem de parâmetros deixa eu te dar mais umas dicas:

Exemplos

Vamos alterar o programa teste para usar as variáveis que acabamos de ver. Vamos fazê-lo assim:

Repare que antes das aspas eu usei uma barra invertida para o escondê-las da interpretação do Shell (se não usasse as contrabarras as aspas não apareceriam). Vamos executá-lo:

Conforme eu disse, os parâmetros recebem números de 1 a 9, mas isso não significa que não posso usar mais de 9 parâmetros significa somente que só posso endereçar 9. Vamos testar isso:

Exemplo:

Vamos executá-lo:

Duas coisas muito interessantes neste script:

1. Para mostrar que os nomes dos parâmetros variam de $1 a $9 eu fiz um echo $11 e o que aconteceu? O Shell interpretou como sendo $1 seguido do algarismo 1 e listou passando1;
2. O comando shift cuja sintaxe é shift n, podendo o n assumir qualquer valor numérico (porém seu default é 1 como no exemplo dado), despreza os n primeiros parâmetros, tornando o parâmetro de ordem n+1, o primeiro ou seja, o $1.

Bem, agora que você já sabe mais sobre passagem de parâmetros do que eu, vamos voltar à nossa “cdteca” para fazer o script de inclusão de CDs no meu banco chamado musicas. O programa é muito simples (como tudo em Shell) e vou listá-lo para você ver:

Exemplos

O script é fácil e funcional, limito-me a anexar ao fim do arquivo musicas o parâmetro recebido. Vamos cadastrar 3 álbuns para ver se funciona (para não ficar “enchendo lingüiça”, vou supor que em cada CD só existem 2 músicas):

Listando o conteúdo de musicas.

Não está funcional como achava que deveria ficar… podia ter ficado melhor. Os álbuns estão fora de ordem, dificultando a pesquisa. Vamos alterar nosso script e depois testá-lo novamente:

Vamos cadastrar mais um:

Agora vamos ver o que aconteceu com o arquivo musicas:

Simplesmente inseri uma linha que classifica o arquivo musicas dando a saída nele mesmo (para isso serve a opção -o), após cada álbum ser anexado.

Oba! Agora está legal e quase funcional. Mas atenção, não se desespere! Esta não é a versão final. O programa ficará muito melhor e mais amigável, em uma nova versão que desenvolveremos após aprendermos a adquirir os dados da tela e formatar a entrada.

Exemplos

Ficar listando com o comando cat não está com nada, vamos então fazer um programa chamado muslist para listar um álbum cujo nome será passado como parâmetro:

Vamos executá-lo, procurando pelo album 2. Como já vimos antes, para passar a cadeia album 2 é necessário protegê-la da interpretação do Shell, para que ele não a interprete como dois parâmetros. Vamos fazer assim:

Que lambança! Onde está o erro? Eu tive o cuidado de colocar o parâmetro passado entre aspas, para o Shell não dividi-lo em dois!

É, mas repare como está o grep executado:

grep $1 musicas

Mesmo colocando álbum 2 entre aspas, para que fosse encarado como um único parâmetro, quando o $1 foi passado pelo Shell para o comando grep, transformou-se em dois argumentos. Desta forma o conteúdo final da linha, que o comando grep executou foi o seguinte:

grep album 2 musicas

Como a sintaxe do grep é:

=grep [arq1, arq2, ..., arqn]=

o grep entendeu que deveria procurar a cadeia de caracteres album nos arquivos 2 e musicas, Por não existir o arquivo 2 gerou o erro, e por encontrar a palavra album em todos os registros de musicas, listou a todos.

Sempre que a cadeia de caracteres a ser passada para o comando grep possuir brancos ou TAB, mesmo que dentro de variáveis, coloque-a sempre entre aspas para evitar que as palavras após o primeiro espaço em branco ou TAB sejam interpretadas como nomes de arquivos.

Por outro lado, é melhor ignorarmos maiúsculas e minúsculas na pesquisa. Resolveríamos os dois problemas se o programa tivesse a seguinte forma:

Neste caso, usamos a opção -i do grep, que como já vimos, serve para ignorar maiúsculas e minúsculas, e colocamos o $1 entre aspas, para que o grep continuasse a ver a cadeia de caracteres resultante da expansão da linha pelo Shell como um único argumento de pesquisa.

Agora repare que o grep localiza a cadeia pesquisada em qualquer lugar do registro, então da forma que estamos fazendo, podemos pesquisar por álbum, por música, por intérprete ou até por um pedaço de qualquer um destes. Quando conhecermos os comandos condicionais, montaremos uma nova versão de muslist que permitirá especificar por qual campo pesquisar.

Aí você vai me dizer:

- Poxa, mas é um saco ter que colocar o argumento de pesquisa entre aspas na hora de passar o nome do álbum. Esta forma não é nem um pouco amigável!
- Tem razão, e por isso vou te mostrar uma outra forma de fazer o que você pediu:

Desta forma, o $*, que significa todos os parâmetros, será substituído pela cadeia album 2 (de acordo com o exemplo anterior, fazendo o que você queria.

Não se esqueça o problema do Shell não é se você pode ou não fazer uma determinada coisa. O problema é decidir qual é a melhor forma de fazê-la, já que para desempenhar qualquer tarefa, a quantidade de opções é enorme.

Ah! Em um dia de verão você foi à praia, esqueceu o CD no carro, aquele “solzinho” de 40 graus empenou o seu CD e agora você precisa de uma ferramenta para removê-lo do banco de dados? Não tem problema, vamos desenvolver um script chamado musexc, para excluir estes CDs.

Antes de desenvolver o “bacalho”, quero te apresentar a uma opção bastante útil da família de comandos grep. É a opção -v, que quando usada lista todos os registros da entrada, exceto o(s) localizado(s) pelo comando. Vejamos:

Exemplos

Conforme eu expliquei antes, o grep do exemplo listou todos os registros de musicas exceto o referente a album 2, porque atendia ao argumento do comando. Estamos então prontos para desenvolver o script para remover aquele CD empenado da sua “CDteca”. Ele tem a seguinte cara:

Na primeira linha mandei para /tmp/mus$$ o arquivo musicas, sem os registros que atendessem a consulta feita pelo comando grep. Em seguida, movi (que, no duro, equivale a renomear) /tmp/mus$$ por cima do antigo musicas.

Usei o arquivo /tmp/mus$$ como arquivo de trabalho, porque como já havia citado no artigo anterior, o $$ contém o PID (Process Identification ou identificação do processo) e desta forma cada um que editar o arquivo musicas o fará em um arquivo de trabalho diferente, desta forma evitando colisões no uso.

- Aê cara, estes programas que fizemos até aqui estão muito primários em virtude da falta de ferramentas que ainda temos. Mas é bom, enquanto eu tomo mais um chope, você ir para casa praticar em cima dos exemplos dados porque, eu prometo, chegaremos a desenvolver um sistema bacana para controle dos seus CDs.
- Quando nos encontrarmos da próxima vez, vou te ensinar como funcionam os comandos condicionais e aprimoraremos mais um pouco estes scripts.
- Por hoje chega! Já falei demais e preciso molhar a palavra porque estou de goela seca!
- Garçom! Mais um sem colarinho!

Vou aproveitar também para mandar o meu jabá: diga para os amigos que quem estiver afim de fazer um curso porreta de programação em Shell que mande um e-mail para a nossa gerencia de treinamento para informar-se.

Qualquer dúvida ou falta de companhia para um chope ou até para falar mal dos políticos é só mandar um e-mail para mim.

Valeu!

Regular expression tutorials for Python and Grep.

Tutorial One

Tutorial Two