Adicionei no projeto Refactoring-scripts um novo script: o remove-temps. Ele apenas busca recursivamente em um diretório por arquivos temporários e os elimina. Como é útil rodar antes de comitar, adicionei a opção -g, ou –git, que executa o comando “git rm” para todos os arquivos temporários, sendo que para utilizar esta opção, deve-se estar na diretório root do projeto e os arquivos ainda devem existir.

[]’s

Em mais um episódio da série “Universidade pública: se você quer alguma coisa feita, não espere o servidor público morcego, faça você mesmo”, alguns amigos e eu tivemos que formatar os PC’s das bancadas de aula. Como em nossas bancadas utilizamos Linux, mais precisamente o Ubuntu, fiz um script em shell para automatizar o processo de configuração das máquinas e instalação dos softwares necessários.
Como também tenho que formatar minha máquina e alguns amigos disseram que também irão formatar as suas, e todos iremos instalar o Ubuntu Karmic Koala, fiz uma adaptação do script das bancadas para uma versão que baixe tudo da Internet, instalando automaticamente diversos softwares básicos que sempre são necessários após uma formatação.
Criei um projeto no github para o script afterFormat.sh. Na imagem abaixo está a interface dos script na qual você pode escolher o que quer instalar ou não.

Dê uma olhada no README para mais informações sobre os softwares que afterFormat instala, como executá-lo e como fazer a configuração básica do StarDict.

[]’s

Mês passado estava trabalhando em um sistema que estou desenvolvendo em Rails com amigos da faculdade quando um deles viu que tinha feito uma merda. Ele tinha criado um modelo “viagem” com o scaffolding mas esqueceu de colocar o plural correto no inflections. Assim o scaffolding criou vários arquivos que continham no nome as palavras “viagems” ou “Viagems” e vários arquivos que tinham em seu conteúdo essas mesmas palavras. Contudo ele já havia programado bastante coisa depois disso e ficaria ruim retornar ao commit anterior no git.
Ele já ia alterar tudo manualmente quando falei: Calma aí! Vou criar um script para isso!
Era uma boa oportunidade, já que estou aprendendo a programar em shell. Em pouco tempo criei dois scripts básicos: um para modificar os nomes dos arquivos e outro para modificar o conteúdo. Logo pensei em montar um conjunto de scripts para refactoring já que uso o combo Gedit + Terminal para programar. Daí essa semana comecei a ler o livro Shell Script Professional do Aurélio Marinho, que é muito bom livro por sinal, e dei uma profissionalizada nos scripts para colocar em prática meus aprendizados.
O resultado está no projeto Refactoring-scripts github. Por enquanto são dois:

- find-replace.sh – Busca em um arquivo, ou recursivamente em todos os arquivos de um diretório, por uma palavra e a substitui por outra.

- change-file-name.sh – Busca recursivamente em um diretório por arquivos que contenham uma palavra em seu nome e a substitui por outra.

A pretensão é, além criar outros scripts, cirar um fork para um plugin de refactoring em python para o gedit.
Mas isso é coisa para as férias de fim de ano. =)

login item에 항목을 추가하는 인스톨러를 만들기 위해 참 많은 시간을 허비했다.
PakcageMaker의 안정적이지 않은 동작으로 애를 먹었었고, 사실 최근 버젼들은 비교적 안정적이었다. 하지만 역시 이해하기 힘든 부분이 있었고, 또한 무슨 일이 왜 발생하는지 인스톨 로그를 보고선 파악하기 힘든 면이 있었다. 이에 대해서 별도로 포스팅을 하겠는데, 그전에 defaults system에 대해서 언급을 해야겠다.
Windows에는 registry란 것이 있다. 여기에 어떤 프로그램을 인스톨했으며, 그 프로그램에서 어떤 세팅을 어떻게 했으며 등등을 기록해 놓는 것이다. 이 registry는 Windows를 쓰면 쓸수록 성능이 떨어지게 만드는 주범 중의 하나이기도 하다. 이런 이유에는 registry를 사용하는 Windows 자체의 문제이기도 하지만, InstallShield나 MSI installer setup project를 만드는게 참 어렵기 때문에, 인스톨 프로그램을 만드는 사람들이 제대로 모든 도큐먼트를 충분히 이해하고 만들지 못하는 이유가 있기도 하다.

Mac은 비교적 깔끔하게 이런 관리를 한다. registry란 단일의 공간이 있다기 보다는 preference를 /Library/Preference나 ~/Library/Preference에 각 프로그램 별로 저장을 한다. com.apple.Safari.plist와 같은 것이 바로 그것이다. 산업계 표준에 맞추어서 그 이름도 com.apple.Safari처럼 해 놓았고, plist는 XML이라 그 내용을 보기도 편하다. 단 text XML이라 그 파일이 커지면 느려지고 커지는 단점도 있어서 요새는 Binary XML도 이용하는 추세이다.
Windows에서처럼 registry란 단일 공간내에 기록될 필요가 없어서, 저장공간 (메모리건 하드디스크건)을 차지하는데 그 공간이 비대해질 염려도 적다. 그러므로 세팅을 찾는데 시간도 적게 걸린다. ( Windows Sys Internals 툴을 이용해보면 Windows가 수시로 registry를 업데이트하는데 시간을 많이 보내고 있음을 볼 수있다. Mac에선 적어도 이런 일은 최소화가 된다. 왜 Windows가 아무일도 안하고 가만히 있는 거 같은데도 수시로 HDD를 긁어대는지 그 이유는 이런데 있다. 물론 background process들도 계속 돌고 있고, 그들이 registry에 써대는 이유도 있지만, 기본적으로 Windows는 registry관리에 CPU time의 일정 부분을 줄기차게 할애한다. )

Mac에서는 각 프로그램들에서 세팅을 하면 그것이 이런 XML파일에 저장이 된다. 프로그램이 설치되서 실행이 되면, 그리고 뭔가 세팅을 저장하면 비로소 이 XML이 생기는데, 아쉽게도 프로그램을 지웠을때, 이 파일들이 자동으로 없어지진 않는다. 이렇게 남아도 Windows처럼 registry란 중앙 집중적인 공간에 저장되지 않기 때문에 퍼포먼스 하락에 그다지 일조하지 않는다. 하지만 Mac에는 다른 문제점이 있는데, 여기에 버그가 좀 있다. 바로 receipt DB란 것이다. 여기에 대해선 뒤에서 언급하기로 하고…

아무튼 세팅을 저장하기 위해선 해당 프로그램을 열어서 거기서 지원하는 preference… 메뉴를 이용해서 주로 바꾸게 되는데…
해당 프로그램을 열지 않고서 바꾸려면 어떻게 해야 하는가? 바로 그 XML 파일들을 직접 열어서 바꿔주면 된다. 근데 이 부분은 user interaction이 들어가서, 때때로 shell script등에서 해주기엔 곤란한 부분이 있다. 이때 바로 쓰는게 defaults system이란 것이다. 종종 Mac OS X Hints와 같은 웹사이트에서 이것을 이용해서 hidden setting을 이용하는게 보인다. 특히 Shell programming을 많이 하게 될 Sys Admin들 입장에서는 defaults system을 아는게 상당히 중요하다.
그러다보면 많이 보게 되는게 바로 MAN page인데.. 문제는 이 MAN page의 설명이 당췌 알아보기가 힘들게 되어 있다는 것이다. MAN page가 그렇듯이 항상 긴 설명에 예제는 거의 없다. 어떤 것을 정의 해 놓고서 그게 뭘 뜻하는 건지 설명이 없기 일쑤다.

자 한번 보자

write domain key 'value'
  Writes value as the value for key in domain.
  value must be a property list, and must be enclosed
  in single quotes.
  For example:
     defaults write com.companyname.appname "Default Color" '(255, 0, 0)'
  sets the value for Default Color to an array containing the strings 255, 0, 0
  (the red, green, and blue components).
  Note that the key is enclosed in quotation marks because it contains a space.

write domain 'plist'
  Overwrites the defaults information in domain with that given as plist.
plist must be a property list representation of a dictionary,
and must be enclosed in single quotes.
  For example:
    defaults write com.companyname.appname '{ "Default Color" = (255, 0, 0); "Default Font" = Helvetica; }';
  erases any previous defaults for com.companyname.appname and writes the values for the two names into the defaults system.

자 이 설명으로 key value 쌍으로 세팅할때는 어떻게 하는지, plist는 어떻게 생겼는지 알 수가 있다.

자 그럼 다음을 보자.

-array      Allows the user to specify an array as the value for the
                given preference key:

                  defaults write somedomain preferenceKey -array element1 element2 element3

                 The specified array overwrites the value of the key if the
                 key was present at the time of the write. If the key was not
                 present, it is created with the new value.

-array-add  Allows the user to add new elements to the end of an array
                 for a key which has an array as its value. Usage is the same
                 as -array above. If the key was not present, it is created
                 with the specified array as its value.

-dict       Allows the user to add a dictionary to the defaults database
               for a domain.  Keys and values are specified in order:

                  defaults write somedomain preferenceKey -dict key1 value1 key2 value2

               The specified dictionary overwrites the value of the key if
               the key was present at the time of the write. If the key was
               not present, it is created with the new value.

-dict-add   Allows the user to add new key/value pairs to a dictionary
               for a key which has a dictionary as its value. Usage is the
               same as -dict above. If the key was not present, it is cre-
               ated with the specified dictionary as its value.

저 array element가 어떻게 생겼는지 알 수가 없다. 또한 dictionary 경우엔 key과 value로 어떤 형태의 데이터를 받아들이는지 알기가 힘들다.
도대체 element는 어떤 type의 것일까?

Login item을 넣기 위해서 구글에서 찾아보았다.
근데 그다지 도움이 되지를 않았다. 대개 간단한 경우에 대해서만 했기 때문이다.
그래서 고생 고생끝에 되는 형태를 찾았는데..

#!/bin/sh
defaults write loginwindow AutoLaunchedApplicationDictionary -array-add '{"Hide" = "True"; "Path" = "/Applications/NEXIO Sync.app";}'
echo "Writing to defaults system is done"

자.. 위의 것은 shell script 파일로 만든 것이다. 편하게 사용하려면 execution 권한을 저 파일에 주면 되는 것이고, 일일히 sh를 호출하기 싫어서 She-Bang라인을 넣어 주었다.
음.. AutoLaunchedApplicationDictionary 아이템에 -array-add 이후의 아이템을 넣는 것인데, 그 자체가 dictionary 형태이다.
즉 한 dictionay를 array로 넣는 것이다. 왜 그럼 -dict-add를 넣으면 안될까? 그건 AutoLaunchedApplcationDictionary의 형태 때문이다. 자 보자..

자.. AuoLaunchedApplicaitonDictionary 키 자체가 여러 아이템을 가지고 있게 되는 형태고, 그 아이템마다 세팅이 있는 것이다.
그러므로 각 아이템이 dictionary이니까, dictionary 자체를 array의 한 아이템으로 넣는 것이다.
그러므로 만약 -dict-add를 이용하면 이미 있는 item1과 item 2가 없어지면서, 한 이이템들이 아닌 AutoLaunchedApplicaitonDictionary 자체의 property들로 key와 value가 세팅이 된다.

이렇게 알고 보면 참 간단한데, 전혀 설명이 없는 상태에서 MAN 페이지의 설명만 봐서는 알기가 힘들다. add 버젼과 아닌 버젼의 차이는, add가 있는 경우는 이미 기존에 있는 것들에 덧붙여서 넣는 것이고, 없는 것은 기존에 있던 것을 갈아치우는 것이다. 이것에 대한 설명은 다행이 있다.

암튼 이렇다.

ADDED : 아.. sed에 익숙한 분이시면 sed를 이용하시는 것도 한 방법이 되겠다.
근데 text processing이 귀찮으니까, 그냥 defautls system을 이용하시는게..
sed를 이용해서 plist파일을 바꾸는 것이 여기에 포스팅 되어 있으니 참고하시면 jump start를 하는데 도움이 될 듯..

Hello All,

I am currently working on crafting a shell script for the i386  platform and x64 platform.  This script will be modeled after Howtoforge’s The Perfect Desktop – Ubuntu 9.10.  I will include several extras to which I feel will make a more complete desktop package.  This scripts will be published by tomorrow (Nov 4th) after I have tested them within Virtual Machines to ensure that they function as designed.  My goal however is to allow a user to install Ubuntu and run my shell script with little effort, thus providing them with a desktop to suit their every need.

Embora comandos de 1 linha nem sempre germ clareza (e por isto os evito), hoje, especificamente, resolvi empregar um “if” em uma linha para um caso em especial.

Como não tenho o costume de usá-los, não lembrava a sintaxe. Nada que o “pai Google” não resolva.

Li este termo semana passada em algum blog e achei bastante original!

Talvez este não seja o link mais específico para meu caso, mas foi o primeiro que encontrei e solucinou-me o problema. Além disto, o blog deste link tem material bastante interessante (e bons autores), que já utilizei em outros casos. Só por isto já vale a referência!

Mas esta seção é para ser simples, então chega de lero-lero e vamos ao comando (aproveitando o exemplo do link citado!):

[ $var -ne 1 ] && echo "Não é 1"

ou ainda:

test -w $file || echo "$file não é gravável"

Não tinha nada o que fazer e resolvi “tentar” adiantar meu próprio lado criando um pequeno shell script para conectar em um servidor em que, de vez em nunca, preciso restaurar ou copiar alguns arquivos de backups da rede ( … tipo naquelas… de uma vez por ano ou uma vez na vida e outra na morte… quando o chefe quer as “fotos da festa de mil novecentos e lá vai bolinha”… ) … sabe como é, existem momentos que ficamos “ociosos”!

Pois bem, o script é muito simples e pode ser útil para diversas outras opções além de “copiar” fotos para seu superior ou para aquela garota que sempre está “incomodando” o cara de T.I. .

O ambiente é simples:

Tenho um servidor Windows 2000 Server, com algumas pastas compartilhadas no AD (com restrições de acesso, leitura e escrita, onde cada usuário possui permissões diferentes: login e senha).

O endereço do servidor é 192.168.0.100, e as pastas compartilhadas, digamos que sejam F, G, H, Informatica, X e Z.

Como não quero utilizar a interface gráfica para isto e quero utilizar um terminal, a “temida” linha de comando (escovando bits no CLI), a maneira mais chata, e a princípio, parecendo a mais rápida, seria fazer isto aqui:

mkdir /media/W2KServer && mkdir /media/W2kServer/F

mount -t cifs -o username=jeferson,password=minhasenhasecreta,gid=users,iocharset=utf8,rw,users,file_mode=0777,dir_mode=0777 //192.168.0.100/F /media/W2kServer/F

Sinceramente, esta não é uma boa ideia, ainda mais que meu usuário e senha, ficaram gravados nos históricos de comandos do bash, e se eu levantar da mesa por um minuto, chegar alguém e ficar por um tempinho em minha sessão aberta, logo poderá ter tais dados muito facilmente.

Ainda bem e para minha própria segurança, posso usar a opção credentials e indicar um arquivo que contém meu usuário e senha, e nisto, não fica a senha a Deus dará… vejam:

mount -t cifs -o credentials=/root/.smb-credents,gid=users,iocharset=utf8,rw,users,file_mode=0777,dir_mode=0777 //192.168.0.100/F /media/W2kServer/F

O ‘pulo do gato’ se dá na criação do arquivo /root/.smb-credents. E o conteúdo do arquivo ser semelhante a este modelo:

username=jeferson

password=minhasenhasecreta

Com isto, resolvo meu problema de segurança de informações pertinentes a meu usuário e senha, mas… Todas as vezes que eu precisar mapear apenas uma unidade na rede, terei que fazer estes passos de criação e montagem de diretórios?

Não é mais fácil colocar tudo no /etc/fstab e pronto?

E se eu ter mais diretórios para mapear, também terei que repetir todos estes comandos para cada unidade de rede presente no servidor que pretendo acessar?

Calma pequeno padawan… paciência é uma virtude!

Não quero ficar digitando estes comandos, toda as vezes que eu precisar acessar tais pastas e creio que você também não. Então, depois de criado o /root/.smb-credents, vamos criar nosso primeiro script para começarmos a automatizar o processo. Criei o arquivo /bin/map.sh, contendo os comandos para montar os diretórios do servidor “SMB“:

http://paste.archlinux-br.org/1351

Veja que não temos nenhum tipo de controle neste arquivo… não há verificação da existência de conexão com o servidor; não verifica a existência dos diretórios necessários a montagem das unidades (/media/W2kServer/?) e muito menos, se há automação de todos estes processos… então, pensei em melhorar isto com a criação de um último script, que se valerá do /bin/map.sh.

O batizei de mapping.sh e o que ele faz exatamente o que o título do post indica:

• Verifica se há conexão de rede e se o servidor com o qual quer se conectar, está ‘ouvindo’ (ou de ‘pé’, como preferir);
• Havendo conexão, ele criará a estrutura necessária para a conexão no diretório /media e por fim;
• Mapeará as pastas disponíveis no servidor, tornando-as acessíveis ao meu usuário.

Para isto, a primeira parte do script definirá uma Variável ( LREAD ):

LREAD=/tmp/lread.pid

LREAD, aponta para um arquivo que ainda não existe (/tmp/lread.pid) , mas que será essencial para o funcionamento de nosso pequeno notável.

Como sei o endereço IP de nosso servidor, e que este endereço nunca mudará, ou não mudará tão cedo até que eu decida que ele mude (forte isto.. neh? xD), utilizo o comando ping, verificando se tal host está visível na rede interna:

ping -c 1 192.168.0.100

O ping com a opção “-c 1“, irá enviar apenas uma requisição solicitando resposta de tal host. O servidor, respondendo, teremos uma saída de informação que se diferencia da saída de erro deste, e isto, nos traz a possibilidade de ‘moldar’ ações, conforme os resultados se apresentem.

Resolvi então, concatenar e “filtrar o resultado” analisando suas diferenças (o caso do comando ping, irá sempre mostrar em suas saídas a ‘palavra’ “icmp_seq=1“), conseguindo isto com ajuda do comando grep. Aproveitando, concateno mais uma vez o resultado, utilizando-se agora do do comando “cut“, veremos que na coluna (carácter) 27, temos números que se diferenciam, trazendo possibilidades, vejam:

O erro nos mostraria a seguinte mensagem:

From 192.168.0.2 icmp_seq=1 Destination Host Unreachable

Caso o servidor estiver funcionando e aceitando conexões, nos mostraria isto:

64 bytes from 192.168.0.100: icmp_seq=1 ttl=128 time=3.43 ms

Em meu caso específico, se houver erro, a coluna 27, me trará o valor 1 no campo ‘icmp_seq’, pelo simples motivo do endereço IP do host que uso, seu último octeto estar abaixo do decimal 10, tendo apenas hum (1) numeral: 192.168.0.2.

Já se houver conexão e resposta, por causa do IP “pingado” ser 192.168.0.100, a coluna 27 da saída do comando ping -c 1 192.168.0.100 | grep icmp_seq=1 | cut -c27 seria o caracter numérico 0, provindo do último octeto do número IP (100).

Então peguei o resultado disto (0 ou 1) e redirecionei para nossa variável LREAD (lembram-se dela, no começo de nossa história? Pois é…).

ping -c 1 192.168.0.100 | grep icmp_seq=1 | cut -c27 > $LREAD

Um passo importante…

Poderiamos utilizar-se do cat, mas neste caso, eu não precisaria declarar a variável LREAD, e prá deixar a coisa mais “bonita”, preferi utilizar-me do ’sobrenatural’ while read para ler o conteúdo do arquivo contido na primeira variável e transformá-lo em uma String lógica temporária. Para isto….

VRF=`while read LN; do echo $LN ; done < $LREAD`

Hehehe…condições… o restante é história, e em um shell script começa a mágica com o uso de if, then, else if, else, fi:

if [ $VRF == 1 ] ; then

Aqui, estou dizendo o seguinte: - Se a variável VRF for igual a 1, então faça…

echo Falha de Conexão com o Servidor

echo Verifique se há conectividade de rede local, ou se o servidor responde a conexões

else if [ -e /media/W2kServer/I ]; then

Caso a variável seja diferente de 1, temos a possibilidade de executar outros comandos e até mesmo buscar e aplicar outras soluções/comandos para potenciais problemas que possam ocorrer, e isto é o que o “else if” me permite ter. Reparem bem que o ‘[ -e /media/W2kServer/I] ‘,verificará se o diretório existe, existindo, ele executará uma ação:

sh /bin/map.sh

echo Unidades de Rede Mapeadas com sucesso

Caso não existir, executará outra ação (; then).

else if [ -e /media/W2kServer ]; then

Observando de perto, criamos inclusive, diretórios que não existem para que o mapeamento funcione corretamente, fechando o circulo perfeitamente (penso eu).

echo Recriando estrutura de diretórios

mkdir /media/W2kServer/{F,G,H,I,X,Z} && sh /bin/map.sh

echo Unidades de Rede Mapeadas com sucesso

E assim, vou testando as possibilidades até elas se findarem e o script se tornar um pequeno programa (quase perfeito), cobrindo todas as possibilidades existentes em meu ambiente.

Continuando… e finalizando!

else

echo Criando estrutura de diretórios

mkdir /media/W2kServer && mkdir /media/W2kServer/{F,G,H,I,X,Z} && sh /bin/map.sh

echo Estrutura recriada e unidades de redes mapeadas com sucesso

fi

fi

fi

Por fim, temos 3 arquivos essenciais (2 shell scripts, e 1 arquivo contendo as credenciais para acesso ao host).

Como escrevi a principio, estes arquivos para me conectar com tal servidor, me atendem perfeitamente, pois, não há a necessidade de que a conexão seja permanente, sendo executada a cada boot. Porém, ter que digitar vários comandos de criação ou verificar se os diretórios existem, e posteriormente, montar as pastas compartilhadas de servidor em tais diretórios, é algo muito massante com o tempo. O ideal, é ser adaptável e nunca tornar seu trabalho algo chato de se fazer, e com isto, ganho em tempo e agilidade, e também não fico “ocioso” com os meus neurônios. Fico feliz de poder compartilhar este pequeno script com todos vocês leitores.

Ahhh… quem ter uma solução melhor, ou ainda, me passar umas ideias, ou mesmo de como aperfeiçoar e diminuir o tamanho dos scripts eu ficarei grato e receberei com alegria tais colaborações.

Os scripts podem ser baixados e visualizados no paste.bin do Archlinux-br, segue os links:

http://paste.archlinux-br.org/1351

http://paste.archlinux-br.org/1353

E nunca se esqueçam do Guia Foca GNU/Linux.

I need to write a program which reads a date string. The program then archives all the data on the server with the input date as an cut off date.

The following java program is based on the tutorial in </dream.in.code>. It reads a date string, validate it and print the number of date difference between today and the input date.

DateCounter.java

import java.util.*;
import java.text.*;

public class DateCounter {

        public static void main(String[] args) {
                SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
                Date inputDate = null;

                // parse the input date string
                try {
                        inputDate = sdf.parse(args[0]);
                } catch (ParseException e) {
                        // Incorrect input date format. Program exits.
                        System.out.println("Incorrect date format: " + args[0]);
                        System.out.println("Valid Date format:     dd/mm/yyyy");
                        return;
                }

                // Check whether the date is a valid date
                if (!sdf.format(inputDate).equals(args[0])) {
                        // Invalid input date. Program exits.
                        System.out.println("Invalid date input: " + args[0]);
                        System.out.println("Please correct the above input date.");
                        return;
                }

                /* Validation passed */

                // Get today date
                Date today = new Date();
                System.out.println("Today:     " + sdf.format(today));
                System.out.println("InputDate: " + sdf.format(inputDate));

                // Calculate the Date difference
                long dateDiff = (inputDate.getTime() - today.getTime()) / 86400000;
                dateDiff++;

                // Print the difference
                System.out.println("Still have " + dateDiff + " day(s) to go.");

                /* and do whatever you want ... */
        }
}

And i also write a shell script which will compiles the DateCounter.java and prompt for a date input in shell.

run_date_counter.sh

#!/bin/sh

# Complile the DateCounter.java
javac DateCounter.java

# Get the date input from user
echo "****************"
echo "* Date Counter *"
echo "****************"
echo "Date Format: dd/mm/yyyy"
echo "Please input a date for calculation: \c"
read _inputDate

# Run the DateCounter
java DateCounter $_inputDate

To run this little program, place them in the same folder and enter
sh run_date_counter.sh

For example, i would like to know how many days i have before Tinyan’s birthday.

****************
* Date Counter *
****************
Date Format: dd/mm/yyyy
Please input a date for calculation: 07/11/2009
Today: 21/10/2009
InputDate: 07/11/2009
Still have 17 day(s) to go.

Algumas pessoas vez ou outra precisam da informação do mac address da placa de rede para qualquer coisa. No meu caso é para simples criação de logs, onde o mac address e o serial são os identificadores da maquina. Fazer isso através do shellscript não é tão complicado, mas, eu pelo menos, não sou muito fã de como as coisas ficam “organizadas” no shell-script. Então podemos fazer praticamente tudo que o shell faz usando python.
Outro dia estava fuçando como fazer isso, já que minha caminhada em python começou a pouco tempo e eu ainda apanho um bocado, mas para “facilitar” ou disseminar o conhecimento colocarei abaixo as linhas de código que achei em um blog de um colega blogueiro.
Primeiramente em shell, poderiamos simplesmente usar um comando e editar a saida dele usando shell. Da seguinte forma:
$mac=$(ifconfig eth0) && mac=${mac:45:25} && echo $mac >> arquivo.txt
a saida no meu caso foi a seguinte:
00:24:00:b0:e7:00
Mas sinceramente isso não fica tão agradavel de se usar… Pelo menos não para mim…
Então podemos fazer um pequeno script em python um pouco mais trabalhoso organizado.
import socket
fd = socket.socket(socket.AF_PACKET, socket.SOCK_RAW)
fd.bind(('eth0', 9999))
mac = fd.getsockname()[-1]
print ':'.join(['%02x' % ord(n) for n in mac])

O script em python da mesma forma que o shell apresentará a mesma saida, porém as possibilidades são muito maiores do que se pode fazer.
00:24:00:b0:e7:00

OBS1. O script funciona bem em qualquer Linux. Para qualquer outro sistema você tem que saber qual modulo substitui o AF_PACKET.

OBS2. Você pode usar uma interpretação do comando ifconfig ou ipconfig no python como acontece no shell script mas isso não seria muito normal de se fazer.

Teste…

Fazem 11 meses e 1 dia que escrevi o post sobre como gerar gráficos em shell acessando um banco de dados Oracle.

Repare na coincidência do dia e mês dos 2 posts!

Então para último Dia da Liberdade de Software que participei, resolvi montar uma palestra relâmpago sobre este assunto. A ideia era mostrar que era possível gerar gráficos com dados armazenados em um banco de dados a partir do shell.

Como se tratava de um evento sobre liberdade de software, eu não poderia utilizar um banco de dados proprietário! :p Então reescrevi minha função para acessar os dados armazenados em um MySQL.

Vejam as voltas que o mundo dá… Enquanto escrevo este post a Oracle é quase dona do MySQL (falta a união européia decidir)!

Aqui é possível encontrar a versão do programa em shell acessando o MySQL. Também deixo disponível a palestra, caso tenham interesse.

Para o MySQL precisei criar uma função para extração dos dados e geração do arquivo de trabalho (em Oracle, essa execução estava dentro do próprio programa shell). A função criada no MySQL está comentada dentro do próprio .sh.

# cat domain_dump.sh
var_remote=’remote_ip_address’
mkdir /root/dump_temp/
mysql -u admin -p`cat /etc/psa/.psa.shadow ` -e “show databases” |grep -v “-” |grep -Ev ‘Database|information_schema’ >> /root/backuplist
for i in `cat /root/backuplist`;
do
echo “database is $i”
mysqldump -u admin -p`cat /etc/psa/.psa.shadow` $i > /root/dump_temp/$i.sql
echo “dump of $i created”
done
echo “Creating the tar file in /root”
cd /root
tar -cvzf /root/dump_`date +”%Y-%m-%d”`.tar.gz dump_temp/
lftp $var_remote<<EOF | sort>$TMPFILE
user “username” “password”
cd IP/directory
put dump_`date +”%Y-%m-%d”`.tar.gz
EOF
echo “Deleteing the backup files”
rm -rf /root/dump_temp
rm -rf /root/dump_`date +”%Y-%m-%d”`.tar.gz