Esse artigo e voltado para explicação do que é o NMAP e de como instalá-lo e utiliza-lo. Antes disso é interessante passar o conceito de ferramentas de detecção, pois o NMAP é uma.

Ferramentas de detecção

As ferramentas de detecção nada mais são do que um sistema que analisa se um computador tem portas UDP ou TCP abertas, ele faz uma varredura pelas mais de 65000 portas existentes nesses protocolos.

A forma como essa detecção é feita varia de programa para programa e claro, da forma como cada um é utilizado. De uma forma geral, podemos falar que as ferramentas instaladas em uma máquina enviam pacotes para um servidor (ou uma máquina qualquer), direcionando esse pacotes para cada uma das portas existentes, quando ele recebe uma confirmação do pacote, isso significa que a porta X a qual foi encaminhada um pacote está ativa.

Esse é um modo bem simples de se ver o processo de detecção de portas. Com os avançados sistemas de firewall que existem hoje em dia esse procedimento não daria certo, pois eles são capazes de restringir acesso de redes externas, mas com o NMAP podemos camuflar (mudar) nosso IP e assim tentar confundir o firewall, mas isso será visto mais a frente.

Outra maneira de detecção usada pelas ferramentas é a do envio de pacotes especiais, esse pacotes são exclusivos para portas que estação fechadas. Ora, se uma porta não responder significa que a mesma está aberta. Essa é apenas uma noção que devemos ter sobre ferramentas de detecção.

Obtendo o NMAP

Antes de tudo precisamos instalar os pacotes do NMAP:

• nmap-3.50-3.i386.rpm
• nmap-frontend-3.50-3.i386.rpm

Você pode encontrá-los a partir de rpm.pbone.net ou através do site oficial do software: www.insecure.org/nmap/.

Esses são os dois pacotes necessários para a utilização do NMAP, para instalarmos utilizaremos os seguintes comando:

# rpm -ivh nmap-3.50-3.i386.rpm
# rpm -ivh nmap-frontend-3.50-3.i386.rpm

Pronto, depois disto já estaremos com o nosso programa instalado e para que tenhamos certeza disso, vamos usar os comandos abaixo para verificar:

$ rpm -q nmap
$ rpm -q nmap-frontend

Se obtivermos uma saída mostrando a versão do pacote, pimba!!! Nosso pacote está instado.

Depois de passar por essa etapa vamos agora para sua sintaxe de utilização. Vale lembrar que ele não possui daemon e com isso não precisamos ativar nenhum serviço.

Sintaxe:

nmap <opção> NET/HOST

Opções do NMAP

Opções do NMAP

• -sP => Essa opção envia um pacote ICMP Ping Scan, que é usado para encontrar um host na rede.

Exemplo:

# nmap -sP 10.100.102.39/24

OBS: O /24 é referente a máscara de rede.

• -sU => Essa opção determina quais portas UDP estão ativas.

Exemplo:

# nmap -sU 10.100.102.39

Podemos colocar também um número de rede.

• -sS => Essa opção já e mais aprimorada, além de mandar o pacote e esperar uma confirmação, no meio da conexão ele a interrompe, com isso ele consegue burlar algumas sistemas de proteção. O -sS procura por portas do tipo TCP.

Exemplo:

# nmap -sS 10.100.102.39

A saída deste comando irá lhe mostrar as portas abertas e os seus respectivos serviços que estão rodando.

• -sT => Similar a opção -sS, só que ela tem uma maior garantia de sucesso, ou seja, ela é melhor.

Enganando um firewall

O NMAP também pode burlar os firewalls que são configurados para descartar os pedidos de conexões de outras redes, como já foi comentado no início.

Para isso mudaremos a opção -D, que na verdade vai camuflar seu IP e com isso conseguiremos fazer nossa varredura.

Essa opção será utilizada em conjunto com as outras vindo a frente das demais. Exemplo:

# nmap -sS 10.100.102.39 -D 10.100.102.113,200.192.35.6

Onde:

• 10.100.102.39 é o IP o qual vou fazer a verificação.
• 10.100.102.113 é o meu IP é.
• 200.192.35.6 é um IP qualquer que escolher para que camufle o meu.

Usando essa opção associada com as outras temos uma das melhores buscas por portas possível.

Examinado portas específicas

Com isso podemos examinar determinadas portas em um determinado IP ou rede. Veja um exemplo:

# nmap -sT -p 22,23,110 10.100.102.37

Onde:

• 22,23,110 => portas desejadas.
• 10.100.102.37 => IP ou rede de destino.

Usando isso associado às opções citadas e um bom conhecimento de portas, podemos conseguir bons resultados!

Scaneando faixas de IPs

Em uma rede podemos querer apenas fazer uma varredura em alguns IPs, ou seja, em uma faixa de IPs específica e isso e extremamente possível.

Para scanearmos uma determinada faixa de IPs usamos o seguinte comando:

# nmap -sX -p 22,23,110 10.100.*.1-12

A opção “-sX” nos permite especificar uma determinada faixa de IPs. O comando acima fará uma varredura em todas as redes de prefixo “10.100″ e em cada rede buscará apenas nos IPs de 1 à 12.

Identificando o sistema operacional

Sabemos que a vulnerabilidade está associada ao sistema operacional, pois cada um tem sua particularidade, por isso é importante saber qual é o sistema operacional de uma máquina em determinadas situações.

Para descobrir detalhes sobre o sistema operacional, usamos:

# nmap -sX -O IP/HOST

A opção “-O” pode ser associada a qualquer outra do NMAP.

Teremos assim uma descrição do sistema operacional em questão.

Resumo

Como foi visto nesse artigo, o NMAP é uma ótima ferramenta de detecção que nos traz muitas opções de uso.

O software em geral é usado por administradores de redes para que possa ser feita uma boa análise contra invasões e prevenções das mesmas.

O NMAP é útil para vários tipos de tarefas e recomendado para qualquer um que tenha contato em modo geral com redes.

Esse artigo trata do conceito usado pelas ferramentas de detecção e faz um tour pelas principais funcionalidades do NMAP. Dentre elas podemos citar: varreduras de rede, identificação de portas abertas, identificação de sistema operacional, camunflagem de IP dentre outras.

No related posts.

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

O preço era de direita e um pouco mais de US $ 100 por mês eu tenho um servidor bom com 2 GB de memória, 500GB de banda mensal, uma CPU rápida todo o meu ego, a abusos como eu achar melhor.

Fast forward to UFC 77. Você vê que eu executar um web site que faz previsões e os resultados UFC UFC. Na noite de luta, o site pode ficar bastante movimentado, o meu anterior, alta foi de 18.000 visitantes nos 3 ou mais horas que as brigas ocorrem. Minha conta de hospedagem compartilhada nunca tive um problema com esta carga, pelo menos não tanto quanto eu poderia dizer. No entanto, com o UFC 77 na minha conta de hospedagem dedicada de novo o meu servidor atingiu uma parede de tijolos. A CPU estava em 100% e houve 200 processos apache todos competindo para o CPU e memória disponível. Imediatamente comecei a procurar razões e mais importante de soluções. Três dias depois, eu acho que a maioria das minhas respostas.

É importante saber que o Go Daddy não houve culpa, eu perguntei para uma caixa com especificações determinadas, e que é exatamente o que eles me deram, completo com todos os softwares que eles disseram. MySQL, PHOP 4.3.9 e Apache 2.0.52. Então comecei a procurar (quando o servidor se acalmou) com o que estava acontecendo quando um usuário requisitou uma página. A primeira coisa que eu notei foi que o processo apache corrente levaria cerca de 5% da CPU, eu não prestar atenção a quanto tempo ele correu. A próxima coisa que eu notei foi que o MySQL também aproveita CPU significativo, mesmo que apenas por um curto período de tempo. É importante saber que, durante o UFC 77 MySQL estava levando cerca de 50% da CPU durante todo o período ocupado. Tempo para procurar algumas otimizações.

Para o meu site, onde existem 20.000 visitantes em 3 horas e talvez 10 atualizações durante esse tempo, o cache seria, obviamente, ser útil. Notei pesquisar na web que o Apache tem cerca de cache e ainda melhor alguns cache min, no entanto, não se considera produção pronta no 2.0.52 build que eu tenho, por isso, descartada a idéia bastante rápido. Eu entretanto notar algumas coisas quando eu olhei para otimizações MySQL.

A otimização do MySQL mais importante que eu encontrei é a opção query_cache_size. Você vê, o MySQL tem esse conceito de cache de consulta, aqui está uma explicação simples. Se eu fizer uma consulta simples, digamos

Customer_name SELECT cliente onde customer_id> 10 (eu sei, uma pergunta boba)

Geralmente, o banco passa por toda a sua magia e devolve o resultado conjunto de todos os nomes de clientes que o id são superiores aos 10. Para esta consulta não tomaria muito tempo, mas quanto mais complexa a consulta a mais que seria necessário. No entanto, com o MySQL cache de consulta, o resultado dessa consulta seria mantida na memória, juntamente com a consulta em si, o que significa que da próxima vez que a mesma consulta foi executar o banco de dados seria apenas verificar se há tabelas na consulta ter sido alterado e, em seguida procurar o resultado na memória e devolvê-lo. Isto é muito mais rápido. O MySQL tem consulta cache ativado por padrão, mas a variável query_cache_size é definido como 0, essencialmente desactivar a funcionalidade. Para ativá-la você deve fazer:

query_cache_size = 64M em my.cnf

Nota: Eu também aumentou minha query_cache_limit de 4M e meu thread_cache_size a 384. Há muitas outras opções MySQL que você pode definir para melhorar o desempenho, procurar um bom livro MySQL ou talvez eu vou postar algumas delas no meu depósito de fonte aberta blog at [http://www.open-source-depot.com / blog].

Depois de configurar as opções no my.cnf você precisará reiniciar o MySQL, sendo que eu sou do tipo impaciente e não gosto de reiniciar o processo, fui para a linha de comando do MySQL e definir as opções globais. Por alguma razão os 64M não trabalho para mim lá, então eu usei o expandido (bytes) version

ou seja, mysql> SET GLOBAL query_cache_size = 60000000;

para ver o que está definido, faça um:

mysql> SHOW VARIABLES LIKE have_query_cache ‘;

Nota: Você precisa dizer ao MySQL para “ir” com ag na próxima linha.

Agora eu tentei bater o meu blog um pouco e descobri que nunca a CPU para o MySQL foi mais de 1 ou 2 (exceto para o primeiro hit), muito muito legal. Eu devo fazer uma nota que eu encontrei algumas referências sobre a rede onde o cache de consulta no MySQL realmente degrada o desempenho de determinadas circunstâncias. Eu diria que em um ambiente de atualização pesados (um carrinho de compras, por exemplo) que a sobrecarga do cache pode outweight é usefullness, mas para sites como mina onde é 99,9% da leitura e escrita de apenas 1% de cache de consulta é impressionante. Existem outras otimizações MySQL que eu quero olhar, como cache de tabela e talvez até mesmo persistente connections, mas um passo de cada vez. Eu quero ver que tipo de diferença esta mudança um vai fazer. Eu estou esperando por coisas boas. Meu próximo passo é o cache do PHP, mas vou guardar isso para outro artigo.

Fonte: http://www.compute-rs.com

Related posts:

1. Gerando log das “queries” lentas do MySQL Primeiramente verifique se a variável que gera o log está...
2. Alterando a senha do usuário root no MySQL Algumas vezes já me deparei com a dificuldade de tentar...
3. Scripts de conexão ao MySQL – PHP Existem funções no PHP específicas para conexão ao servidor e...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Related posts:

1. Integração simples do Apache 2 com Tomcat 5 Tutorial Basico de integração do Apache 2 com Tomcat. Instalando...
2. Instalando e Integrandro Apache2 com Tomcat5 Introdução Nesse artigo vamos demonstrar a integração do servidor web...
3. Tutorial Tomcat – Instalação e Configuração Básica Nota: Na revisão 13 deste tutorial, o conteúdo foi bastante...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

O sistema de autodetecção do Slax não é tão desenvolvido quanto o de distribuições como o Ubuntu, Knoppix ou Mandriva, mas ajuda bastante.

Você pode baixar a última versão no: http://slax.linux-live.org/.

Além do “Slax Standard Edition”, que é a versão principal, que abordo aqui, estão disponíveis algumas versões específicas, como o KillBill (que vem com o wine pré-instalado) e o PopCorn (uma versão reduzida, que pode ser instalado num pendrive de 128 MB).

O Slax configura o vídeo durante o boot, mas não abre o modo gráfico automaticamente. Na tela de login, você deve se logar como root, senha toor e rodar o comando “startx” para abrir o KDE. Você pode também usar a opção “slax gui” na tela de boot, para que ele abra o KDE automaticamente, como no Kurumin.

Embora seja raro, existem casos em que o sistema trava na hora do boot por causa de problemas com a detecção de algum periférico. Nestes casos, você pode experimentar as opções “slax noagp”, “slax nopcmcia”, “slax nodma” ou “slax acpi=off”.

Ao abrir o modo gráfico, você verá uma versão personalizada do KDE, com um visual simpático e um menu limpo, com poucos programas instalados por padrão. Devido à simplicidade, o tempo de boot também é perceptivelmente mais baixo.

Para configurar o som, use o comando “alsaconf”, e para configurar a rede, use o “netconfig” (o mesmo script usado no Slackware). Se você acessa via ADSL com autenticação (PPPoE), use o comando “adsl-setup” para configurar a conexão e depois o “adsl-start” para conectar. Estes dois comandos podem ser encontrados também no Mandriva, Fedora e em outras distribuições derivadas do Red Hat.

{mospagebreak}

O Slax não inclui suporte a nenhum softmodem, mas se por acaso você utilizar um hardmodem, pode conectar usando o Kppp, como em outras distribuições.

O suporte a placas wireless também não conta com todos os drivers disponíveis mas ele já vem com o Ndiswrapper pré-instalado, que permite configurar muitas placas usando os drivers do Windows. Você pode ver dicas de como configurar sua placa usando o Ndiswrapper no Guia Modems e placas wireless no Linux: http://www.guiadohardware.net/guias/05/

Em resumo, você primeiro carrega o arquivo .inf do driver do Windows XP, com o comando “ndiswrapper -i”, como em:

# ndiswrapper -i neti2220.inf

… e, em seguida, ativa o Ndiswrapper usando o comando:

# modprobe ndiswrapper

Com a placa ativa, você pode configurar os parâmetros da rede wireless e monitorar a conexão através do Kwifimanager, que está dentro do menu internet.

O Slax não oferece nenhuma opção de alterar o particionamento durante a instalação. Você precisa criar as partições previamente, usando o cfdisk e formatá-las através do comando “mkreiserfs”, como em “mkreiserfs /dev/hda2″. Outra opção, é particionar usando um CD do Kurumin, ou o CD de instalação do Mandriva e voltar ao Slax para instalar. Mesmo ao particionar a partir do próprio Slax, usando o cfdisk, é sempre necessário reiniciar, para que o instalador detecte as alterações.

O instalador está disponível no “Iniciar > System > Slax Installer”. Ele é provavelmente o instalador mais simples de todas as distribuições que já vi. Você precisa apenas indicar a partição onde o sistema será instalado e no MBR de qual drive o lilo será gravado (caso tenha mais de um). Não existe a opção de instalar o lilo na partição, caso você esteja instalando-o em dual boot com o Windows ou outra distribuição. Ele sempre se gravará na MBR e você precisará configurar o “/etc/lilo.conf” para que ele lhe dê a opção de inicializar os outros sistemas instalados.

{mospagebreak}

Existem duas formas de instalação. A opção “Live” simplesmente copia o conteúdo do CD para a partição, ocupando apenas 200 MB. Esta opção é mais uma opção para poder dar boot sem usar o CD-ROM do que uma instalação propriamente dita, algo similar a usar a opção “tohd” no Kurumin. A opção “Real” ocupa quase o triplo de espaço, pois nela os arquivos são realmente descompactados, criando uma instalação real do sistema, onde você pode instalar novos programas e fazer qualquer tipo de alteração.

Mesmo depois de instalado, o Slax continua usando o root como usuário padrão. Enquanto você estiver brincando e explorando o sistema isto é até interessante, pois permite que você mexa onde quiser, sem ser perturbado por problemas com as permissões. Se alguma coisa der errado, basta reinstalar e começar de novo.

Mas, a partir do momento em que você resolver navegar na web ou fazer qualquer trabalho mais sério, o uso do root torna-se um grave problema de segurança por dois motivos: como root você tem permissão para fazer tudo, então acaba sendo muito fácil destruir o sistema e, ao mesmo tempo, abrindo todos os programas como root, fica muito mais fácil explorar brechas de seguranças nos programas para obter acesso à sua máquina remotamente. Esta segunda possibilidade não é tão grande assim, mas vale a pena evitar.

{mospagebreak}

Você pode criar um novo usuário usando o comando adduser, como em:

# adduser tux

São feitas muitas perguntas, que permitem incluir informações diversas no cadastro do usuário (que seriam úteis numa grande rede), mas, no caso de um humilde desktop, as únicas que realmente interessam são o nome em si (login) e a senha.

Depois de instalado, o Slax nada mais é do que uma versão customizada do Slackware. O que você aprender a fazer no Slax pode ser feito também no Slackware e vice-versa.

Um dos grandes atrativos do Slax é ser um sistema bem simples e limpo, com poucos programas instalados por padrão. Isto é uma faca de dois gumes, pois também significa que ao usar o sistema por mais tempo, você acabará precisando investir mais tempo baixando e instalando programas adicionais.

O Slax é compatível com os pacotes da versão correspondente do Slackware. O Slax 5.06, por exemplo, usa os pacotes do Slackware 10.2. Normalmente, a última versão do Slax usa os pacotes da última versão do Slackware.

Você pode instalar programas adicionais a partir dos CDs de instalação (do Slackware) ou ir baixando individualmente os programas desejados a partir de um dos mirrors listados no http://www.slackware.com/getslack/.

Para instalar o suporte a português do Brasil no KDE, por exemplo, baixe o pacote kde-i18n-pt_BR, que está disponível na pasta “slackware/kdei/” do CD ou mirror. Os pacotes do Slackware usam a extensão “.tgz”. Junto com cada pacote, existe sempre um arquivo “.txt”, com uma descrição curta e um arquivo “.asc”, usado pelo instalador para verificar a integridade do pacote principal.

Para instalar o pacote baixado, use o comando “installpkg”, seguido pelo nome do pacote, como em:

# installpkg kde-i18n-pt_BR-3.4.2-noarch-1.tgz

Use a tecla TAB para completar o nome do arquivo depois de digitar as primeiras letras. O installpkg é uma ferramenta simples de instalação, que funciona de uma forma similar ao “dpkg -i” do Debian. Ele permite instalar pacotes que você já baixou, mas não é capaz de baixar os pacotes por si só, como o apt-get. O installpkg também não checa dependências ao instalar os pacotes: mesmo que exista algum problema, você só saberá depois de tentar abri-lo.

Esta forma simplificada de instalar programas é a principal característica do Slackware. A vantagem é que você literalmente pode fazer o que quiser, sem que ele te perturbe com mensagens de erro e dependências desencontradas. A desvantagem é que ele não faz nada sozinho; a única maneira de descobrir que o pacote x precisa do pacote y para funcionar é pesquisando.

Depois de instalado o pacote, acesse o Painel de Controle do KDE, Regional & Accessibility > Contry, Region & Language e, dentro dela marque a opção Add Language > Brazil Portuguese. Clique no “Apply” e reinicie o KDE para que os aplicativos passem a usar nossa língua.

{mospagebreak}

Para instalar o Gimp, baixe o pacote “gimp”, que está na pasta “slackware/xap”; para instalar o Firefox, baixe o pacote “mozilla-firefox” que está na mesma pasta; e assim por diante. O Slax já vem com o plugin do Flash pré-instalado; experimente instalar também o Java e Real Player, seguindo as instruções do capítulo 5 depois de instalar o Firefox.

Para instalar o OpenOffice 2.0, baixe o pacote para o Slackware, disponível no: http://www.openoffice.org.br/ e instale-o usando o comando:

# installpkg openoffice.org.br-2.0-i586-4.tgz

Depois de instalado, você pode completar a instalação do corretor ortográfico e usar as otimizações que vimos no capítulo 5.

O Slackware utiliza uma estrutura de scripts diferente da das outras distribuições. No Debian e na maioria das outras distribuições, você usaria o comando “/etc/init.d/ssh start” para inicializar o servidor SSH e permitir que sua máquina possa ser acessada a partir de outros micros da rede local. No Slackware, isso funciona de forma similar, mas os scripts mudam de lugar, vão na pasta “/etc/rc.d/”.

Para instalar o servidor SSH no Slax, por exemplo, instale o pacote “openssh-4.2p1-i486-1.tgz” que está dentro da pasta “slackware/n/” do CD ou mirror de instalação do Slackware. Ao instalar o pacote, será criado o arquivo “/etc/rc.d/rc.sshd”, o script que permite inicializá-lo. Para usá-lo, você precisa primeiro transformá-lo num executável, usando o comando:

# chmod +x /etc/rc.d/rc.sshd

E, em seguida, inicializar o servidor SSH, usando o comando:

# /etc/rc.d/rc.sshd

O fato de ser uma distribuição minimalista, com tamanho reduzido e rápida de instalar, faz com que o Slax seja uma forma muito prática de se familiarizar com o Slackware, já que você pode testar a instalação de vários programas, testar várias configurações e reinstalar o sistema rapidamente sempre que alguma coisa der errada.

Fonte: GuiadoHardware.net

Autor: Carlos E. Morimoto

Related posts:

1. Instalando um servidor Jabber (Jive) para comunicação Instatânea Neste tutorial eu irei ensinar como instalar um servidor de...
2. Instalando e configurando o Interbase Server Abaixo vai um tutorial simples e prático para instalação do...
3. Instalando e Integrandro Apache2 com Tomcat5 Introdução Nesse artigo vamos demonstrar a integração do servidor web...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Neste tutorial eu irei ensinar como instalar um servidor de comunicação instatânea baseada no protocolo Jabber utilizando o mysql para autenticação, para ser usado dentro de empresas, grupos e etc.

A instalação é bem simples e se for bem seguida, você não terá problemas.

Então deixemos de conversa e vamos logo ao que interessa.

Sistema Operacional Utilizado

• Debian Linux Versão 3.1

Softwares necessários

• Jive Messenger versão 2.1.5 ou superior.
• Mysql 3.4 ou superior. Recomendado usar >= 4.1
• JRE 1.5 ou superior para linux. Pode ser adquirido no site da sun.

Instalação e Configuração

Mysql

Usando o apt-get ou através de mecanismos da sua distro faça o download e instalação do mysql. (Não irei ensinar a configurar e instalar o mysql, para isso existem vários tutoriais na net).

Crie um database chamado jabber.

Crie uma conta de usuário no mysql ou use a conta do root. Recomendado não usar o root. Esse usuário deverá ter permissões para se conectar de qualquer lugar, ou seja, “%”.

O motivo: durante a configuração do jabber o mesmo ira acusar erros caso o usuário que você especificar não estiver conforme eu descrevi.

Você pode tentar limitar o acesso desse usuário permitindo logon somente local após a instalação. Comigo não funcionou.

JRE 1.5

No site da Sun[1], baixe o arquivo .BIN do JRE-1.5 no diretório /usr/local. Aqui utilizei a jre-1_5_0_04-linux-i586.bin

Deixe o arquivo ser executavel.

# chmod +x jre-1_5_0_04-linux-i586.bin

Execute o arquivo digitando:

# ./jre-1_5_0_04-linux-i586.bin

Após concordar com os termos de licença, irá surgir uma pasta chamada jre1.5.0_04 no diretório corrente.

Servidor Jabber

Nesta instalação vamos usar o Jive versão 2.1.5.

Faça o download do jive no site http://www.jivemessenger.com

Descompacte-o arquivo no diretório /usr/local

# tar -zxvf jive_messenger_2_1_5.tar.gz

Feito isso é hora de criar uma variavel de ambiente utilizada pelo jive para identificar a localização da máquina virtual java.

# export INSTALL4J_JAVA_HOME=/usr/local/jre1.5.0_04/

Chegada a hora de iniciarmos o servidor. Digite:

# /usr/local/jive_messenger/bin/messenger start

Se tudo estiver correto o servidor estará funcional.

Abra um browser qualquer e aponte para o ip do servidor na porta 9090

Se tudo der certo você estará na área administrativa começando a configurar o servidor.

Preencha os campos que o sistema requer e vá avançando.

Após concluir a configuração, você deve alterar as permissões do usuário mysql que o jive usa, limitando elas.

A configuração do Jive é muito fácil e lembra os wizards do windows.

Após completar a configuração do servidor, é chegada a hora de baixar o client e testar. Recomendo o uso do Pandion e NeosMt (Meu preferido).

Instale o client do NeosMt[2]

Vá em criar nova conta. E onde ele pedir o servidor, você deverá colocar ip ou nome do servidor em que foi feita a instalação.

Criado a conta agora é só logar com o usuário@servidor e senha.

Conclusão

Pronto temos um servidor Jabber de comunicação Instantânea.

Até mais e abraços.

Autor

• ’1c3_m4n (iceman@underlinux.com.br)

Fonte: http://under-linux.org

Related posts:

1. Como Montar um Servidor NTP O que é? A grosso modo podemos dizer que o...
2. Servidor web – Apache – dicas e tutoriais Sobre este documento Versão simplificada do documento em formato texto,...
3. Instalando e Integrandro Apache2 com Tomcat5 Introdução Nesse artigo vamos demonstrar a integração do servidor web...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Detalhe interessante, a configuração default de um servidor MySQL for Linux, é que o nome dos objetos seja case-sensitive, mais interessante ainda é que mesmo criando uma tabela com o “create table NomeDaTabela(…”, ele entende como se fosse “nomedatabela” (minúsculo), isso acontece pois o MySQL tem uma configuração “lower_case_table_names” que tem 3 formas de serem configurados:

lower_case_table_names=0
- O nome da tabelas é armazenado da forma que foi inserido, e o uso deve ser exatamente igual a forma que foi criado.
Se estiver usando um sistema Windows ou Mac,essa configuração é desprezada e utilizada lower_case_table_names=2.

lower_case_table_names=1
- Os nomes das tabelas são armazenados em minúsculo, e a forma de uso é a mais flexível pois não é case sensitive.

lower_case_table_names=2
- O nome da tabelas é armazenado da forma que foi inserido, mas quando for usar deve ser utilizado o nome em minúscula.

Para configurar é simples, é só abrir o arquivo my.cnf que está na pasta da instalação do MySQL.

Fonte: http://www.tassiohenrique.com.br

Related posts:

1. Backup de Tabelas de Bancos MySQL Scripts Bash para gerar dumps de tabelas de bancos MySQL....
2. Tutorial MySQL: Criando usuários e concedendo privilégios O MySQL possui um sistema de privilégios que é semelhante...
3. Gerando log das “queries” lentas do MySQL Primeiramente verifique se a variável que gera o log está...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Conecte ao servidor com o usuário root e depois se transforme no usuário “postgres” como no exemplo abaixo:

root@pgsql1:~# su – postgres

Agora que está com o usuário postgres, execute o seguinte comando:

postgres@pgsql1:~$ psql template1

Logado no “cliente do postgres” digite o seguinte comando:

template1=# ALTER USER postgres WITH PASSWORD ‘SUA_NOVA_SENHA’;

Agora digite “\q” para sair, desconecte do servidor e tente conectar com a sua aplicação ou seu cliente PostgreSQL ao seu servidor com a nova senha.

Fonte: http://dotlinux.net

Related posts:

1. Alterando a senha do usuário root no MySQL Algumas vezes já me deparei com a dificuldade de tentar...
2. Instalação do PostgreSQL no Linux Numa instalação no Linux, mesmo com a versão 8.3.6, podemos...
3. Introdução ao PostgreSQL Resumo da História do PostgreSQL É um poderoso SGBD com...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Primeiro passo ao formatar…
Você deve ter em mente que este comando fará com que obtenha perca total dos arquivos aplicativos e tudo que esta dentro d um hd. Somente ficará no HD os arquivos necessários da inicialização do mesmo.
Salve seus arquivos em cd’s ou até mesmo disquetes dependendo do arquivo e tal.

Agora o proximo passo é ter certeza d que o CD d Windows XP é com boot…pq se não for não faça a formatação.
IMPORTANTE: Nunca perca nem estrage os CD’s quem vem com os driver do seu pc. Pois sem eles principalmente o da placa-mãe você terá muitos e muitos problemas. Então guarde os CD’s em lugar arejado, fresco, evite lugares úmidos e quentes pois isso prejudica os cd’s.

Tendo em mãos todos os drivers, o CD do windows bootable e sua CD-Key estamos prontos para começar.

Primeiro passo.
Coloque o CD bootable do windows e reinicie a maquina.
Assim quando ela ligar novamente fique apertando DEL varias vezes até aparecer essa tela:

Escolha a opção ADVANCED SETUP(no meu caso nao era advanced setup, se o seu tambem nao for escolha mesmo assim a segunda opção). Aparecerá a seguinte tela:

1ST BOOT DEVICE você colocará a opção CD-ROM(se essa opção nao estiver disponivel continue tentando modificar..tente sair e entrar do advanced setup e veja se mudou…). Feito isso saia do setup do windows mas nao esqueça de salvar as modificações… (lembrando que esse tutorial é para quem tem o CD do windows nao disquetes).
Repita aquele processo de apertar, só que ao inves de DEL vc aperta F8.
Depois vc escolhe a opção CD-ROM para que o computador inicie com o CD d instalação do Windows XP. Logo apos aparecerá a seguinte tela:

Aperte qualquer tecla, mas não demore muito tempo pq vc perde o que salvou e o windows inicia sozinho.
Depois de apertar qualquer tecla aparecera a seguinte tela:

Eu peço que vc não mude nenhuma configuração pois as configurações contidas tem em 99% dos CD’s do Windows XP.
Só mexa se vc tem certeza do que esta fazendo ou de que vc tenha um técnico experiente ao seu lado.
Próxima tela é:

Apenas espere.
Próxima tela é:

ENTER inicia-se o processo de formatação.
R ela faz reparos para eventuais erros do sistema.
F3 vc cancela tudo.
Suponho que vc queira formatar então vamos à proxima tela:

Nesta tela aparece onde será salvo o windows.
ESC vc prossegue com a formatação.
R vc repara o windows que ja esta instalado no seu pc.
Próxima tela é:

Aqui vc deve ter cuidado e prestar atenção!
Se voce quiser fazer uma partição no seu pc (o que é altamente recomendavel) voce aperta C.
Um HD particionado tem menos risco de virus e caso voce nao tenha CD’s para eventuais back-up’s voce nao precisa formatar as duas partições.
Se o seu pc ja estiver particionado apenas exclua a partição onde se encontra o sistema operacional, que provavelmente deve ser C:
Para excluir apenas aperte D na partição selelcionada. Por que isso? Excluindo a partição voce remove possiveis erros e defeitos que o HD criou com o passar do tempo.
Se o seu HD for particionado aperte D para excluir a partição desejada (se o seu HD nao for particionado pule esta parte).
Próxima tela é:

Aperte ENTER para excluir a partição selecionada.
Próxima tela é:

Precione L para continuar com o processo de exclusão da partição.
O windows XP o pergunta duas vezes se vc deseja excluir mesmo a partição porque depois da exclusão tudo será perdido.
Próxima tela é:

Aperte C para criar uma nova partição, e aumente a quantidade de MB nela de acordo com sua necessidade.
Apertando D vc exclui outra partição o que nao vem ao caso.
Caso vc queira somente uma partição no seu HD não faça nada somente va para próxima tela.
Próxima tela:

Aqui que a formatação se inicia preste bastante atenção!
É altamente recomendavel que vc use NTFS normal pois é mais seguro, não use NTFS rápido (quick).
Próxima tela é:

Deixe carregar até o 100% e ela começara a carregar novamente, deixe-a carregar até o final.

Parabens…
O windows está formatado…O sistema de instalação iniciara sozinho… Apenas acompanhe o windows e responda todas as perguntas.
Ps:NÃO REMOVA O CD DO WINDOWS!
Próxima tela é:

Antes do sistema reiniciar automaticamente ele pede pra vc retirar os disquetes (se algum estiver dentro da maquina)
!CUIDADO É SÓ DISQUETE O CD TEM QUE CONTINUAR LÁ SE NÃO VC PERDE TUDO QUE FEZ!
Próxima tela é:

A instalação do windows se inicia…
Apenas acompanhe…
Próxima tela é:

O windows vai reiniciar o sistema, e vc tera que colocar cd key, etc, etc…
AINDA NAO RETIRE O CD…SÓ TIRE QUANDO TUDO ESTIVER PRONTO E VC ESTIVER NA AREA DE TRABALHO DO WINDOWS.

Pronto sua formatação esta pronta.

Fonte: http://helldanger1.blogs.sapo.pt/

Related posts:

1. Instalando e Integrandro Apache2 com Tomcat5 Introdução Nesse artigo vamos demonstrar a integração do servidor web...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

1. Operadores

2. Redirecionamento

3. Variáveis especiais

4. Expansão de variáveis

5. Blocos e agrupamentos

6. if, for, select, while, until, case

if COMANDO
then
   ...
elif COMANDO
then
   ...
else
   ...
fi

for VAR in LISTA
do
    ...
done

ou:

for ((exp1;exp2;exp3))

while COMANDO
do
    ...
done

case $VAR in
    txt1) ... ;;
    txt2) ... ;;
    txtN) ... ;;
    *)    ... ;;
esac

7. Opções do comando test ou [

8. Escapes especiais para usar no prompt (PS1)

9. Escapes reconhecidos pelo comando echo

10. Formatadores do comando date

11. Formatadores do comando printf

12. Letras identificadoras de arquivos no comando ls -l

13. Curingas para nomes de arquivo (glob)

14. Curingas para os itens do comando case

15. Sinais para usar com trap/kill/killall

Como obter a listagem: trap -l, kill -l ou killall -l
Veja também: man 7 signal

16. Códigos de retorno de comandos

17. Códigos de cores (ANSI)

18. Os metacaracteres das expressões regulares

19. Metacaracteres que são diferentes nos aplicativos

20. Caracteres ASCII imprimíveis (ISO-8859-1) - texto

$ zzascii
32        64  @     96  `    162  ¢    194  Â    226  â
33  !     65  A     97  a    163  £    195  Ã    227  ã
34  "     66  B     98  b    164  ¤    196  Ä    228  ä
35  #     67  C     99  c    165  ¥    197  Å    229  å
36  $     68  D    100  d    166  ¦    198  Æ    230  æ
37  %     69  E    101  e    167  §    199  Ç    231  ç
38  &     70  F    102  f    168  ¨    200  È    232  è
39  '     71  G    103  g    169  ©    201  É    233  é
40  (     72  H    104  h    170  ª    202  Ê    234  ê
41  )     73  I    105  i    171  «    203  Ë    235  ë
42  *     74  J    106  j    172  ¬    204  Ì    236  ì
43  +     75  K    107  k    173       205  Í    237  í
44  ,     76  L    108  l    174  ®    206  Î    238  î
45  -     77  M    109  m    175  ¯    207  Ï    239  ï
46  .     78  N    110  n    176  °    208  Ð    240  ð
47  /     79  O    111  o    177  ±    209  Ñ    241  ñ
48  0     80  P    112  p    178  ²    210  Ò    242  ò
49  1     81  Q    113  q    179  ³    211  Ó    243  ó
50  2     82  R    114  r    180  ´    212  Ô    244  ô
51  3     83  S    115  s    181  µ    213  Õ    245  õ
52  4     84  T    116  t    182  ¶    214  Ö    246  ö
53  5     85  U    117  u    183  ·    215  ×    247  ÷
54  6     86  V    118  v    184  ¸    216  Ø    248  ø
55  7     87  W    119  w    185  ¹    217  Ù    249  ù
56  8     88  X    120  x    186  º    218  Ú    250  ú
57  9     89  Y    121  y    187  »    219  Û    251  û
58  :     90  Z    122  z    188  ¼    220  Ü    252  ü
59  ;     91  [    123  {    189  ½    221  Ý    253  ý
60  <     92  \    124  |    190  ¾    222  Þ    254  þ
61  =     93  ]    125  }    191  ¿    223  ß    255  ÿ
62  >     94  ^    126  ~    192  À    224  à
63  ?     95  _    161  ¡    193  Á    225  á

21. Caracteres ASCII imprimíveis (ISO-8859-1) - imagem

22. Códigos prontos para copiar e colar

23. Atalhos da linha de comando (set -o emacs)

24. A caixa de ferramentas do shelleiro

Fonte: http://aurelio.net/shell

No related posts.

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Para verificar quais são os volumes lógicos utiliza-se o comando:

lvdisplay

O espaço disponivel pode ser visto com o comando:

vgdisplay

No exemplo abaixo aumenta-se o volume lógico lv em 2 GB:

lvextend -L +2G /dev/vg/lv

Pronto a partição já foi aumentada. O único problema é que o sistema de arquivos ainda não sabe disso. Execute o próximo passo de acordo com o seu sistema de arquivos:

• Sistemas de arquivos XFS (pode ser executado com o sistema on-line, ou seja, com a partição montada):

xfs_growfs /home

• Sistemas de arquivos ReiserFS (pode ser executado com o sistema on-line, ou seja, com a partição montada). Neste caso deve-se especificar o nome do dispositivo:

resize_reiserfs -f /dev/rootvg/home

• Sistemas de arquivos EXT3:

umount /home
resize2fs /dev/rootvg/home
mount /dev/rootvg/home /home
Fonte: http://wiki.sj.cefetsc.edu.br/

No related posts.

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Apache é a implementação open source de um servidor HTTP. Ele é o webserver mais popular na Internet. Uma pesquisa realizada em 2005 pela NetCraft mostra que cerca de 70% dos sites na Internet rodam sobre o Apache.

Opções de Configuração em tempo de Compilação

Carrege apenas os módulos necessários

O servidor Apache é um programa modular onde o administrador pode escolher entre as funcinalidade que deseja incluir no servidor selecionando um pacote de módukis. Os módulos podem ser compilados estaticamente no binário httpd ou dinamicamente como DSOs(Dynamic Shared Objects). Módulos DSO podem ser compilados quando o servidor for compilado ou poem ser compilados utilizando o apxs para adicioná-los mais tarde. O modulo mod_so deve ser compilado estaticamente no Apache para que o suporte a DSO seja ativo.

Execute o apache apenas com os módulos necessários. Isto reduz o consumo de memória aumenta a performance do servidor. Compilar os módulos estaticamente irá reduzir o consumo de RAM que é utilizado para suportar módulos compilados dinamicamente, mas será necessário recompilar o apache toda vez que um módulo for adicionado ou removido. È aqui que o DSO se torna útil. Uma vez que o modulo mod_so seja compilado estaticamente, qualquer outro módulo pode ser inserido ou removido utilizando o comando LoadModule no arquivo httpd.conf – , mas você terá que compilar os módulos utilizando apxs se ele não foi compilado quando o servidor foi feito.

Escolha o MPM apropriado

O apache vem com uma selação de Módulos Multi-Processadores (MPMs) que são responsáveis por abrir as portas de rede na máquina, aceitando requisições, e despachando processos para cuidar das requisições. Apenas um MPM pode ser carregado por vez.

Escolher o MPM depende de vários fatores, por exemplo se o SO suporta threads, quanta memória está disponível, escalabilidade versus estabilidade, modulos externos,etc .. Sistemas Linux podem escolher entr utilizar um MPM com suporte (worker) a threads ou um prefork sem threads:

O MPM Worker utiliza múltiplos processos. Ele é multi-threaded com cada processo e cada thread cuidando de uma única conexão. Esté é mais rápido e mais escalável e a memória consumida e relativamente baixa. Funciona bem com múltiplos processadores. Porém, o worker é menos tolerante a módulos defeituosos, e threads defeituosas podem afetar todas as outras threads de um processo.

O MPM Prefork utiliza múltiplos processos filhos, cada filho cuidad de apenas uma conexão por vez. Prefork é muito bem gerenciada por processadores simples ou múlitplos, a velocidade é comparável ao worker e é mais tolerante a falhas em modulos e processos que terminam inesperadamente. Mas o consumo de memória é alto, mais tráfego leva a mais consumo de memória.

Opções de Configuração em Tempo de Execução

DNS lookup

A diretiva HostnameLookips habilita a consulta de DNS, então os hostnames podem ser logados ao invés de endereços IP. Isto adiciona latência em cada requisição desde que a consulta do DNS tem que ser completada antes que a requisição seja terminada. Esta opção é desabilitada por padrão no Apache 1.3 e superiores. Deixe isto inativo e utilize programas pós-processamento como o logresolve para determinar os IPs dos logs. Logresolve vem com Apache.

Quando utilizar as diretivas Allow from ou Deny from, utilize endereços IP ao invés de nomes de domínios. Caso contrário uma consulta dupla ao DNS será executada para ter certeza de que o domínio ou host não está sendo spoofado.

AllowOverride

Se o AllowOverride está setado para ‘None’, então o Apache irá tentar abrir o arquivo .htaccess (especificada pela diretiva AccessFileName) em cada diretório que for acessado. Por exemplo:

DocumentRoot /var/www/html
<Directory />
AllowOverride all
</Directory>

Se uma requisição for feita para acessar /index.html, o Apache irá tentar abrir /.htaccess, /var/.htaccess, /var/www/.htaccess, and /var/www/html/.htaccess. Estas tentativas aumentam a latência. Se o arquivo .htaccess for necessário para um diretório, habilite apenas para este diretório.

 FollowSymLinks e SymLinksIfOwnerMatch

Se a opção FollowSymLinks estiver setada, então o servidor permitirá que links simbólicos possam ser seguidos neste diretório. Se a opção SymLinksIfOwnerMatch estiver setada, então o servidor permitirá acessar o link apenas se o destino dele bater com o dono do link.

Se a opção SymLinksIfOwnerMatch estiver setada, então o Apache terá que realizar consultas adicionais ao sistema para verificar se os donos coincidem. Chamadas adicionais também são necessárias quando a opção FollowSymLinks NÃO está setada. Por exemplo:
DocumentRoot /vaw/www/html
<Directory />
Options SymLinksIfOwnerMatch
</Directory>
Para uma requisição feita para /index.html, o Apache irá executar lstat() em /var, /var/www, /var/www/html, and /var/www/html/index.html. Estas requisições adicionais também irão aumentar a lantência. Os resultados do lstat não são cacheados, então as consultas irão ocorrer em cada requisição.

Para uma máxima performance, sete FollowSymLinks em cada lugar e nunca sete SymLinksIfOwnerMatch. Ou então, se SymLinksIfOwnerMatch for necessário para um diretório, sete ele para apenas este diretório.

 Content Negotiation

Evite utilizar content negotiation para respostas mais rápidas. Se content negotiation é necessário para o site, utilize arquivos type-map ao invés da diretiva Options MultiViews. Com MultiViews, Apache precisa scanear o diretório em busca de arquivos, o que adiciona latência.

 MaxClients

O MaxClients seta o número máximo de clientes simultâneos que pode ser suportada por cada servidor. Nenhum processo além do que está definido será aberto. Ele não deve conter um número muito baixo já que as requisições serão colacadas em fila, o que eventualmente irá dar time-out e os recursos do servidor continuarão não utilizados. Setar este valor muito alto irá causar o início de swap e o tempo de resposta irá cair drasticamente. O valor apropriado para MaxClientes pode ser calculado por: MaxClientes = Total RAM / Tamanho Máximo de Processos . O tamanho dos processos para arquivos estáticos é de mais ou menos 2-3MB. Para dinâmicos como PHP, deve ser por volta de 15MB. A coluna RSS de:
# ps -ylC httpd --sort:rss
Mostra a memória física non-swapped utilizada pelos processos do Apache em kilo Bytes.

Se existem mais usuários concorrentes do que MaxClients, as requisições serão colocadas em fila até o número baseado na diretiva ListenBacklog. Aumente o ServerLimit para setar o MaxClients acima de 256.

 MinSpareServers, MaxSpareServers, e StartServers

MaxSpareServers e MinSpareServers determina quantos processos filhos devem ser mantidos rodando. Se MinSpareServers for muito baixo e muitas requisições forem iniciadas, então o Apache terá que abrir processos adicionais para atender as requisições. Criar processos filhos é relativamente caro. Se o servidor estiver ocupado criando processos, ele não estará disponível para servir as requisições imediatamente. MaxSpareServers não deve ser muito alto, ele pode causar problemas de recursos desde que cada processo consome os recursos da máquina.

Sete MinSpareServers e MaxSpareServers para um valor com que o Apache não precise frequentemente abrir mais de 4 processos por segundo. (O Apache pode abrir o máximo de 32 processos por segundo). Quando mais de 4 processos por segundo forem abertos, uma mensagem será logada no ErrorLog.

A diretiva StartServers define o número de processos criados na inicialização do Apache. O Apache irá continuar abrir os processos até que alcance o número de MinSpareServers. Não afeta muito a performance já que o servidor não é reiniciado frequentemente. Se existem muitas requisições e o Apache é reiniciado frequentemente, sete este valor para um número alto.

 MaxRequestsPerChild

A diretiva MaxRequestsPerChild definie o número de requisições que um processo do servidor irá gerenciar. Depois as requisições MaxRequestsPerChild irão morrer. É definido para 0 por padrão, o que significa que o processo não irá expirar nunca. É apropriado setar este valor para alguns milhares. Isto pode ajudar a previnir vazamento de memória desde que o processo morre depois de servir um número de requisições. Não sete este valor muito baixo, já que criar novos processos causa overhead.

 KeepAlive and KeepAliveTimeout

A diretiva KeepAilve permite que múltiplas requisições possam ser enviadas pela mesma conexão TCP. Isto é útil para páginas com muitas imagens. Se o KeepAlive estiver Off, então para cada imagem, uma nova conexão TCP precisa ser aberta.

KeepAliveTimeout determinada quanto tempo deve esperar até a próxima requisição. Sete para um valor baixo, por volta de 2 a 5 segundos. Se for setado para um valor muito alto, os processos ficam amarrados esperando pelo cliente quando eles poderiam ser utilizados para servir novos clientes.

 Compressão HTTP & Caching

O servidor utiliza os métodos gzip ou deflate para as respostas payload antes que ele seja enviado para os clientes. Então o cliente descompacta o payload. Não existe necessidade de instalar softwares adicionais no lado do cliente desde que a maioria dos navegadores suporta isto. Utilizar compressão irá economizar banda e irá aumentar o tempo de resposta, estudos mostram que em média o ganho da compressão é de 75%. A compressão pode ser habilitada utilizando módulo mod_deflate. O Payload é compactado apenas se o navegador requisitar a compactação, ou então o conteúdo descompactado será enviado. Um navegador capaz de utilizar o conteúdo compactado envia o seguinte cabeçalho na requisição: "Accept-Encoding: gzip,deflate". Então o servidor irá enviar o payload compactado e o cabeçalho da reposta é "Content-Encoding: gzip"

O exemplo a seguir utiliza o telnet para verificar os cabeçalhos de requisição e de resposta:
bash-3.00$ telnet www.webperformance.org 80
Trying 24.60.234.27...
Connected to www.webperformance.org (24.60.234.27).
Escape character is '^]'.
HEAD / HTTP/1.1
Host: www.webperformance.org
Accept-Encoding: gzip,deflate

HTTP/1.1 200 OK
Date: Sat, 31 Dec 2005 02:29:22 GMT
Server: Apache/2.0
X-Powered-By: PHP/5.1.1
Cache-Control: max-age=0
Expires: Sat, 31 Dec 2005 02:29:22 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Content-Length: 20
Content-Type: text/html; charset=ISO-8859-1 

O module mod_cache pode ser utilizado no lado do servidor, está em produção estável na versão 2.2 do Apache.
 Servidor separado para conteúdo estático e dinâmico

Processos do apache para conteúdo dinâmico consome cerca de 3-20MB de RAM. E cresce para acomodar o conteúdo e nunca diminui até que o processo termine. Digamos que um processo cresca até os 20MB para servir um conteúdo dinâmico. Depois de completar a requisição, ele está libre para servir outra requisição. Se vier uma requisição para uma imagem, então esses 20MB de processos está servindo um conteúdo estático que poderia ser executado por um processo de 1MB. A memória é utilizada ineficientemente.

Utilize uma pequena compilação do Apache (com o mínimo de módulos compilados estaticamente) como sendo o servidor front-end para servir conteúdos estáticos. As requisições para conteúdos dinâmicos serão encaminhadas para um apache robusto (compilado com todos os módulos necessários). Utilizar um servidor front-end leve tem a vantagem de que os conteúdos estáticos são enviados rapidamente sem o consumo alto de memória e apenas o conteúdo dinâmico é passado para o servidor robusto.

Encaminhamento de requisições pode ser implementado utilizando os módulos mod_proxy e mod_rewrite. Suponha que exista um servidor apache leve rodando na porta 80 e o robusto na porta 8088. Então a configuração a seguir pode ser utilizada no apache leve para encaminhar todas as requisições de conteúdo dinâmico para o servidor robusto.
ProxyPassReverse / http://%{HTTP_HOST}:8088/
RewriteEngine on
RewriteCond   %{REQUEST_URI} !.*\.(gif|png|jpg)$
RewriteRule ^/(.*) http://%{HTTP_HOST}:8088/$1 [P]
Todas as requisições, exceto as imagens serão encaminhadas para o apache robusto. As respostas são recebidas pelo servidor front-end que as encaminha para o cliente. Todas as respostas aparentam vir de um único servidor. 
 Conclusão

Configurar o Apache para obter o máximo de performance pode ser traiçoeiro, não existem regras rápidas. Entenda as necessidades do servidor web e experimente com várias opções. Utiliza ferramentas como ab e httperf para medir a performance do servidor. Servidores leves como tux, thttpd também podem ser utilizados como servidores front-end. Se um servidor de banco de dados é utilizado, tenha certeza de que ele está otimizado para que ele não crie nenhum gargalo. No caso do MySQL, mtop pode ser utilizado para monitorar querys lentas. Performance de scripts PHP pode ser melhorada utilizando produtos de cache como o Turck MMCache. Ele elimina o overhead da compilação realizando cache dos scripts em seu estado compilado. 
 Bibliografia

http://news.netcraft.com/archives/web_server_survey.html
http://httpd.apache.org/docs/2.2/dso.html
http://httpd.apache.org/docs/2.2/mpm.html
http://modperlbook.org/html/ch11_01.html
http://www.speedupyoursite.com/18/18-2t.html
http://www.xs4all.nl/~thomas/apachecon/PerformanceTuning.html
http://www.onlamp.com/pub/a/onlamp/2004/02/05/lamp_tuning.html
http://httpd.apache.org/docs/2.2/misc/perf-tuning.html
Linux Server Hacks by Rob Flickenger 
 Fonte

http://www.howtoforge.net/configuring_apache_for_maximum_performance
http://under-linux.org/wiki/

Related posts:

1. Reverse Proxy Performance – Varnish vs. Squid (Part 1) Typical web applications require dozens of SQL queries to generate...
2. Integração simples do Apache 2 com Tomcat 5 Tutorial Basico de integração do Apache 2 com Tomcat. Instalando...
3. Servidor web – Apache – dicas e tutoriais Sobre este documento Versão simplificada do documento em formato texto,...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Bem-vindo(a) ao nosso guia de introdução à linguagem Python. Este guia exige que se tenha noção de linguagens de programação e para isso é necessário saber o que são algoritmos e estruturas de dados. Quem já programou em uma outra linguagem, como Visual Basic, Delphi ou C poderá se sentir mais apto a programar em Python com esse guia.

Quem sabe você tem dúvidas conceituais sobre a linguagem. Se for este o seu caso, faça uma leitura na seção de Perguntas e Respostas freqüentes sobre Python.

Pronto para começar? Talvez não, porque é necessário ter certeza que o interpretador Python está instalado na sua máquina. Se você utiliza o Mac OS X, Linux ou outro sistema tipo o Unix então a resposta é provavelmente sim, pois esses sistemas constumam vir com o Python pré-instalado. Se você utiliza o Windows é quase certo que você não tem o interpretador. Para verificar, abra um terminal e digite o comando python -V, uma típica resposta será

Dharma:~ ruda$ python -V Python 2.5

indicando que eu tenho instalado a versão 2.5 da linguagem Python.

1. Guia de Introdução à Linguagem Python
1. Apresentação
2. Primeiras Idéias
3. Modo interativo
4. Tipos de dados, constantes, variáveis e expressões
1. Tipos simples
2. Tipos agrupados
3. Tipos mutáveis e imutáveis
4. Listas
5. Estuturas de controle
1. if
2. else
3. elif
4. Modificador not
5. Tabela de expressões válidas
6. Modificador in
6. Estruturas de iteração ou loop
1. for
2. while
7. Funções
8. Arquivos
9. Tratamento de erros e exceções
1. Raise
10. Módulos
1. Módulos distribuídos com o Python
11. Packages
12. Classes
13. Herança
14. Namespaces
1. Nomes não qualificados
2. Nomes qualificados
15. List Comprehensions
16. Generators
1. Generator Expressions
17. Um exemplo Completo
18. Próximos passos

Guia de Introdução à Linguagem Python
Apresentação

Bem-vindo(a) ao nosso guia de introdução à linguagem Python. Este guia exige que se tenha noção de linguagens de programação e para isso é necessário saber o que são algoritmos e estruturas de dados. Quem já programou em uma outra linguagem, como Visual Basic, Delphi ou C poderá se sentir mais apto a programar em Python com esse guia.

Quem sabe você tem dúvidas conceituais sobre a linguagem. Se for este o seu caso, faça uma leitura na seção de Perguntas e Respostas freqüentes sobre Python.

Pronto para começar? Talvez não, porque é necessário ter certeza que o interpretador Python está instalado na sua máquina. Se você utiliza o Mac OS X, Linux ou outro sistema tipo o Unix então a resposta é provavelmente sim, pois esses sistemas constumam vir com o Python pré-instalado. Se você utiliza o Windows é quase certo que você não tem o interpretador. Para verificar, abra um terminal e digite o comando python -V, uma típica resposta será

Dharma:~ ruda$ python -V Python 2.5

indicando que eu tenho instalado a versão 2.5 da linguagem Python.

Se você tem o Windows é um bom momento para baixar o instalador da linguagem Python, que pode ser obtido em http://www.python.org/ftp/python/2.5.2/python-2.5.2.msi
Primeiras Idéias

Se você NUNCA programou antes, é necessário entender alguns conceitos básicos.

Por exemplo: você sabe o que é um “executável” certo? Experimente abrir um arquivo desses em algum editor de textos. A não ser que você tenha vivido anos na Matrix, não entenderá nada!

Isso acontece porque o programa está escrito, ali, em linguagem de máquina, ou seja, apesar de você não entender nada, o computador entende muito bem.

Mas não pense que alguém escreveu aquilo do jeito que está. Também não foi escrito ao estilo “morse” (10010010110)… inicialmente, o programador escreveu o que chamamos de “código-fonte” em alguma linguagem de programação, como C, C++, Pascal, e, depois de terminado, compilou o código, ou seja, traduziu de C, C++, Pascal para linguagem de máquina (também chamada de Assembly).

Essas linguagens que eu citei acima são as linguagens compiladas, pois antes de serem executadas, seus códigos-fonte devem ser devidamente compilados.

Python não é compilada, mas sim interpretada, assim como PHP, Perl e muitas outras, ou seja, não há o processo de compilação. O que acontece é que o código-fonte (ou script) é “traduzido” direto, através de um interpretador (imagine que ele é um intérprete mesmo, pois é assim que funciona!). Observação: Geralmente, quando uma linguagem é interpretada, existe um código intermediário (bytecode), com o qual o programador não precisa se preocupar. Seria muito lento interpretar diretamente o texto do código fonte. No caso do Python, o bytecode é salvo em arquivos .pyc e .pyo (bytecode otimizado)

Tal fato adiciona muita produtividade à linguagem, já que o processo de programar é somente escrever-rodar, ao contrário de escrever-compilar-rodar. Veja que o ciclo de um programa interpretado é bem mais eficiente, pois a fase de testes é MUITO simplificada:

Python: escrever-testar-corrigir-escrever-testar-distribuir

Linguagem C: escrever-compilar-testar-corrigir-compilar-testar-distribuir

Tecnicamente, qualquer linguagem pode ser compilada ou interpretada, mas as linguagens mais dinâmicas geralmente são interpretadas e as mais estáticas (estilo declare-antes-de-usar) são compiladas.

Se você já tem um interpretador instalado em seu sistema, experimente escrever o seguinte script:

1 print “Olá, mundo”

* Depois, num terminal, digite “python nome_do_script”, e veja como é simples!

Modo interativo

O Python também pode ser usado em modo interativo. Para isso, basta digitar python. E deve aparecer algo parecido com isso:

Python 2.5.2 (r252:60911, Apr 21 2008, 11:12:42) [GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)] on linux2 Type “help”, “copyright”, “credits” or “license” for more information. >>>

Em modo interativo, o Python executa o que voce digitar imediatamente (ou quase…), o que é muito bom para testes e para aprender.

O sinal >>> é o prompt padrão Python. Significa que ele está de prontidão esperando um comando. Se o comando tiver algum resultado, este será mostrado na tela.

Para sair, aperte Control + D (nos UNIXes) ou Control + Z seguido de Enter (no Windows)

Tipos de dados, constantes, variáveis e expressões

Python é dinamicamente tipado, o que significa que se você usou uma variável para armazenar um inteiro, nada lhe impede de usá-la posteriormente para armazenar uma string (frase). Na verdade, variáveis em Python não são declaradas, o que lhe dá muita flexibilidade.

Quem determina o tipo de uma variável é o próprio interpretador. Se você escreve:

1 x = 2
2 FRASE = ‘Isso é um exemplo simples e bobo’

* O interpetador já sabe que x é um inteiro e FRASE é uma string. Mas isso não lhe impede de, posteriormente, escrever

1 x = ‘agora tudo mudou’
2 FRASE = 3.2

Como x já disse, tudo mudou, e isso é bem natural. Na verdade, raras são as vezes em que você precisa se preocupar com tipos. Geralmente você simplesmente atribui um valor a uma variável e pronto! Isso é bem simples. Mas não abuse desse recurso, senão seus programas vão virar uma confusão.

Então aqui vão alguns exemplos de tipos:

1 x = 2                           # Inteiro
2
3 p = 3.1415                      # Real, ou ponto flutuante
4
5 verdadeiro = True               # Boolean
6
7 estringue = ‘alguma frase’      # String
8
9 c = 3 + 2j                      # Complexo
10
11 lista = [3, 4, 5]               # Lista com elementos inteiros
12
13 lista2 = [2,'tres',4.0,[5,6]]   # Lista mista e aninhada
14
15 tupla = (1,2,3,’quatro’)        # Tupla. É como uma lista, mas não pode ser mudada
16
17 # tuplas de 0 ou 1 elementos têm sintaxes especiais:
18 tupla0 = ()
19 tupla1 = (‘primeiro e único item’,) # repare na vírgula
20
21 # Em alguns casos (atribuições, returns), os parênteses são opcionais,
22 # mas na maioria das vezes (tuplas dentro de listas, tuplas dentro de chamadas de funções)
23 # os parênteses são necessários porque a vírgula faz parte de outra sintaxe
24
25 coord = 4.5, 9.1
26 cor_branca = 255, 255, 255 # cor no formato RGB
27 funcao((4.5, 9.1), ‘string’)
28
29 dic = {‘site’:'Python Brasil’,'url’:'www.pythonbrasil.com.br’} # Isso é um dicionário

Tipos simples

* str (Strings, como ‘blabla’)
* unicode (São strs em que os caracteres podem representar qualquer língua, u’blabla’)
* bool (True ou False)
* float (Números em ponto flutuante, como 4.5 ou 3.14e-10)
* int (Números inteiros, como 99)
* long (Números inteiros muito grandes, como 1234567890123456789123456789L)
* complex (Números complexos, como 3.1j ou 7+3.14e-10j)
* file (Arquivos)
*

decimal (integrado ao Python 2.4 como módulo) (Números fracionários representados de forma decimal em vez de binária)

Tipos agrupados

* list (listas)
* tuple (tuplas – listas imutáveis)
* dict (dicionários)
* set (novo tipo incluso no Python 2.4 – uma lista sem repetições)

Tipos mutáveis e imutáveis

Alguns tipos no Python permitem que elementos que fazem parte de sua estrutura sejam modificados, como as listas e dicionários. Estes tipos são chamados mutáveis.

Exemplo:

1 >>> l = ['Nirvana', 'Rush', 'Bauhaus']
2 >>> l[1] = ‘Who’
3 >>> l
4 ['Nirvana', 'Who', 'Bauhaus']
5 >>>

Outros tipos não permitem isso, como tuplas e strings. Estes são chamados imutáveis.

Exemplo:

1 >>> s = ‘MYSQL’
2 >>> s[1] = ‘y’
3 Traceback (most recent call last):
4   File “<stdin>”, line 1, in
5 TypeError: object does not support item assignment

Listas

O tipo lista do Python é bastante sofisticado e flexível. Como classe, a lista conta com métodos para ordenar (sort), inverter (reverse), contar ocorrências de um determinado elemento (count) e outros.

1 >>> # Criando a lista de bandas
2 …
3 >>> lista = ['Led Zeppelin', 'King Crimson', 'Yes', 'The Who', 'Pink Floyd']
4 >>>
5 >>> # Acessando um ítem da lista
6 …
7 >>> lista[0]
8 ‘Led Zeppelin’
9 >>>
10 >>> # Para elementos de listas dentro de listas ou caracteres de strings dentro de listas
11 …
12 >>> lista[0][0]
13 ‘L’
14 >>>
15 >>> # Retornando uma parte da lista (do terceiro até o quarto ítem)
16 …
17 >>> lista[2:4]
18 ['Yes', 'The Who']
19 >>>
20 >>> # Retornando uma parte da lista (do segundo até o fim)
21 …
22 >>> lista[1:]
23 ['King Crimson', 'Yes', 'The Who', 'Pink Floyd']
24 >>>
25 >>> # Retornando uma parte da lista (a partir do inicio até penúltimo)
26 …
27 >>> lista[:-1]
28 ['Led Zeppelin', 'King Crimson', 'Yes', 'The Who']
29 >>>
30 >>> # acessando a lista em passos
31 …
32 >>> lista[::2]
33 ['Led Zeppelin', 'Yes', 'Pink Floyd']
34 >>>
35 >>> # Passo negativo
36 …
37 >>> lista[::-1]
38 ['Pink Floyd', 'The Who', 'Yes', 'King Crimson', 'Led Zeppelin']
39 >>>
40 >>> # Convertendo para uma string
41 …
42 >>> ‘, ‘.join(lista)
43 ‘Led Zeppelin, King Crimson, Yes, The Who, Pink Floyd’
44 >>>
45 >>> # Contando ocorrências
46 …
47 >>> lista.count(‘Yes’)
48 1
49 >>>

As estruturas condicionais disponíveis no Python são if, elif e else.

O if, o elif e o else servem para examinar expressões. À grosso modo, pode-se dizer que eles avaliam se determinada expressão retorna Verdadeiro (True) ou Falso (False).

Em Python os valores vazios: None, [] (* Lista vazia), “”, 0. São tidos como Falso (False). E os outros valores são verdadeiros (True).

Explicado isso, vamos às explicações:

if

Antes uma breve explicação do que vem a ser if. Como é sabido, if é traduzido em português para “se”. Nas linguagens de programação esse “se” (if) atua como um verificador de condições, algo como:

se ( essa condição for verdadeira ):

esse bloco de comandos
será executado

Traduzindo em um exemplo bobo em Python, teriamos:

1 if (10 > 5):
2     print “10 é maior do que 5″

No caso, o bloco (composto apenas por um comando, no caso) seria sempre executado. Os parênteses na “condição” são opcionais.
Vamos a outros exemplos.

Obs: Os exemplos são do modo interativo (shell) do Python.

1 # Exemplo IF 01
2 >>> meuNome = “Juares”
3 >>> seuNome = “Adolfo”
4 >>> if meuNome == seuNome:
5 …     print “Nos temos os nomes iguais”
6 …

Você notou que o print não ocorreu, já que as variáveis meuNome e seuNome são diferentes. Na linha 3 o if verifica essa igualdade, mas como o valor retornado da verificação é falso, ele não executa o comando print.

Agora observe esse outro exemplo:

1 # Exemplo IF 02
2 >>> meuNome = “Adolfo”
3 >>> seuNome = “Adolfo”
4 >>> if meuNome == seuNome:
5 …     print “Temos os nomes iguais”
6 …
7 Temos os nomes iguais

Viu? Agora imprimiu, já que as variáveis são iguais. O if, novamente na linha 3, fez a verificação de igualdade (==) e obteve resultado Verdadeiro (True), logo executou o comando print.

else

Se o if refere-se ao “se”, quando traduzido, o else refere-se ao “senão”. Exemplificando:

se ( condição for verdadeira ):

execute esses comandos
esse também

senão:

execute
esses comandos

No caso o “se” é o if e o “senão” o else. Note que o else é executado se o if não for executado, ou seja, a condição do if não foi atendida. Caso o if tenha sido executado, o else não é executado.
Vamos a um exemplo em código Python:

Obs: Estes códigos também são exemplos do shell do Python.

1 #Exemplo ELSE 01
2 >>> meuNome = “Ruivaldo”
3 >>> seuNome = “Adolfo”
4 >>> if meuNome == seuNome:
5 …     print “Temos nomes iguais”
6 … else:
7 …     print “Nossos nomes sao diferentes”
8 …
9 Nossos nomes sao diferentes

Reiterando. O else não verifica nada. Ele é só uma delimitação de código a ser executado caso o if não ocorra.
Mais um exemplo, só para fixar:

1 # Exemplo ELSE 02
2 >>> x = 5
3 >>> y = 10
4 >>> if x > 5:
5 …     print “X maior que Y”
6 … else:
7 …     print “Y maior ou igual a X”
8 …
9 Y maior ou igual a X

Nesse exemplo nós não sabemos quando o Y é igual ao X. Teríamos que usar o elif, que veremos agora.

elif

O elif é uma mistura de if com else. Calma, não se assuste. Ele é um else, logo só é executado se o if não ocorrer, só que além de else ele também é um if, então pro bloco elif ser executado além do primeiro if não ser executado, deve-se atender a uma determinada condição.

Em portugol seria algo como:

se ( condição ):

executa comando
comando

se-if-não-foi-executado-e ( condição ):

executa comando
comando

senão:

comando comando
comando

Como já foi dito: o “se” é o if, o “se-if-não-foi-executado-e” é o elif e o “senão” é o else.

Vamos a um exemplo similar ao anterior:

1 #Exemplo ELIF 01
2 >>> x = 5
3 >>> y = 10
4 >>> if x > y:
5 …     print “X maior que Y”
6 … elif x == y:
7 …     print “X igual a Y”
8 … else:
9 …     print “Y maior que X”
10 …
11 Y maior que X

Note que agora se o x for igual ao y ele irá imprimir uma mensagem. Veja esse outro exemplo:

1 # Exemplo ELIF 02
2 >>> x = 5
3 >>> y = 5
4 >>> if x > y:
5 …     print “X > Y”
6 … elif x == y:
7 …     print “X == Y”
8 … else:
9 …     print “X < Y”
10 …
11 X == Y

Pronto. Estude os códigos, o conceito do elif é um pouco estranho mesmo, mas um pouco de estudo é o suficiente para dominá-lo.
Modificador not

O modificador not é uma palavrinha que serve pra negar a expressão do if ou elif. Ao invés de esperar o valor verdadeiro da expressão ,o if vai esperar pelo valor falso. Estudemos-o por um exemplo:

1 # Exemplo not
2 >>> x = 5
3 >>> y = 6
4 >>> if not x == y:
5 …     print “X eh diferente de Y”
6 …
7 X eh diferente de Y

Tabela de expressões válidas

Você pode usar os seguintes símbolos em suas expressões if, elif:

>= (Maior Igual) > (Maior) <= (Menor Igual) < (Menor) == (Igual) = (Diferente) <> (Diferente)

* E para finalizar essa seção do tutorial, o modificador in.

Modificador in

O in verifica se um elemento está dentro de outro. É como o símbolo de contido da matemática. Em portugol seria algo:

se elemento está-contido-em elemento-listável:

comando
comando

Traduzindo. O “se” está para o if e o “está-contido-em” para o modificador in. Porém temos ali um “elemento-listável”. Meio estranho esse termo. Calma. Existem cinco tipos de elementos listáveis em Python: dicionários, listas, tuplas, strings (que são no fundo listas de caracteres) sets.

Isto é, no lugar de elemento-listável só pode haver uma variável dos tipos acima.

Vejamos esses exemplos:

1 >>> if 1 in [1,2,3]: print “Esta”
2 …
3 Esta
4 >>> if ‘a’ in “aloha”:
5 …     print “Esta tambem”
6 …
7 Esta tambem
8 >>> if [2,3] in [1,2,3]:
9 …     print “Esta”
10 …
11 >>> if [2,3] in [[2,3],[2,4]]:
12 …     print “Esta denovo”
13 …
14 Esta denovo

Conselho: Para fixar os conceitos copie e execute todos os exemplos no shell do Python, assim você aprenderá.
Estruturas de iteração ou loop

for

Se você programa em C, vai perceber que o for em Python é diferente. Ele itera sobre listas. Por exemplo:

if not odeio_metallica:

metallica = ['James','Kirk','Lars','Trujillo']
for membro in metallica:
print membro

Ou seja, para cada elemento da lista, itere. Você terá acesso ao item corrente (print membro). Se quiser fazer iterações sobre progressões aritméticas, use a função range, que cria uma lista de inteiro em seqüência. Exemplo:

1 for i in range(50):
2    print i

Isso vai imprimir na tela os números de 0 a 49.

while

O while é muito simples. Ver o exemplo já vai ajudar muito:

1 opc = 1
2 while opc != 0:
3    # código e mais código…
4    opc = int(raw_input(“Digite 0 para sair \n > “))

Veja, o laço vai continuar iterando até que o usuário digite 0 na hora que o programa perguntar. Simples. O while é literalmente um “enquanto ISSO faça AQUILO”.

Tando o for quanto o while podem ser interrompidos por break (o loop termina). O comando continue interrompe a iteração corrente e passa para a próxima.
Funções

Simplificando, uma função é um bloco de código que tem nome (pelo qual ele pode ser chamado), recebe paramêtros (opcional) e gera um resultado (opcional)

Exemplo:

1 def media(lista = [0]):
2     return float(sum(lista)) / len(lista)
3
4 print media([1,2,3,4,5])

media é o nome da função. lista é o paramêtro da função (no caso de vários paramêtros, seus nomes devem ser separados por vírgula). [0] é o valor padrão para lista (opcional)

return termina a execução da função, retornando o resultado (opcional) e o controle para a rotina que a chamou.
Arquivos

Trabalhar com arquivos no Python é bem fácil. Como o Python é uma linguagem orientada a objetos, um arquivo é um objeto da classe file.

Um arquivo pode ser aberto para leitura (‘r’, o padrão), escrita (‘w’) ou inclusão (‘a’) ou para ler e gravar no mesmo arquivo (‘w+’). Se um arquivo já existir e for aberto apenas para escrita (‘w’), ele será zerado.

1 # Um texto para teste…
2
3 texto = Beautiful is better than ugly.
4 Explicit is better than implicit.
5 Simple is better than complex.
6 Complex is better than complicated.
7 Flat is better than nested.
8 Sparse is better than dense.
9
10 # Salvando em um arquivo chamado “zen.txt”
11
12 f = file(‘zen.txt’, ‘w’)
13 f.write(texto)
14 f.close()
15
16 # Posso fazer em uma única linha:
17
18 file(‘zen.txt’, ‘w’).write(texto)
19
20 # Para ler o arquivo:
21
22 arq = file(‘zen.txt’)
23
24 # Trazendo o texto de volta:
25
26 texto = arq.read()
27
28 # Se preferir uma lista contendo as linhas do arquivo
29
30 linhas = arq.readlines()
31
32 # Se movendo para o inicio do arquivo
33
34 arq.seek(0)
35
36 # Imprimindo as linhas do arquivo:
37
38 for linha in arq: print linha,
39
40 # Fechando o arquivo
41
42 arq.close()

Tratamento de erros e exceções

* try / except
* try / finally

As sentenças try / except e try / finally são mutuamente excludentes, não podem misturadas (embora possam ser usadas uma no interior da outra)

A sentença try / except especifica um ou mais manipuladores de exceção. Caso não ocorra erros, nenhum manipulador será executado. Ainda é possível definir um else opcional que será executado quando nenhum erro ocorrer. Exemplo:

1 try:
2     # Vou tentar fazer isso:
3     x = 1/0
4 except ZeroDivisionError:
5     # Se houver divisão por zero, farei isso:
6     print ‘Divisão por zero…’
7 else:
8     # Senão…
9     print ‘Não ocorreu nenhum erro!’

A sentença try / finally especifica um manipulador de limpeza, que será executado sempre. Quando não ocorre erros, finally é executado. Quando ocorre um erro, a exceção é salva, finally é executado, e logo após a exceção salva é executada novamente. Exemplo:

1 try:
2     x = 1/0
3 finally:
4     print ‘Tentando dividir um 1 por 0… Ops!’

Nesse caso, o traceback aparecerá na tela, depois da mensagem.
Raise

Com a sentença raise, você pode provocar uma exceção, que ser pode tratada pelo código que chamou aquela parte do programa. Exemplo:

1 try:
2     z, y = 1, 0
3     if y == 0:
4         raise ZeroDivisionError
5     else:
6         print ‘%d divido por %d é %d’ % (z, y, z/y)
7 except ZeroDivisionError:
8     print ‘Divisão por zero…’
9 else:
10     print ‘ocorreu algo inesperado!’

Dica: raise SystemExit termina o programa.
Módulos

Um módulo em Python não é nada mais que um arquivo .py com definições de funções e classes. É isso mesmo. Apenas um arquivo.

Para facilitar o entedimento vamos exemplificar.

Escrevemos o código do seguinte módulo (logicamente, para fins didáticos apenas):

Esconder número das linhas

1 # Exemplo de módulo
2 # Módulo matematica.py
3
4 def somar(a,b):
5     “”"
6     Funcao que soma dois numeros
7     “”"
8     return a+b
9
10 def subtrair(a,b):
11     “”"
12     Funcao que subtrai dois numeros
13     “”"
14     return a – b
15
16 def multiplicar(a,b):
17     “”"
18     Funcao que multiplica dois numeros
19     “”"
20     return a * b
21
22 def dividir(a,b):
23     “”"
24     Funcao que divide dois numeros
25     “”"
26     return a / b

Salvamos ele como “”matematica.py”".

Agora vamos escrever três exemplos de uso do módulo.

* Importando o módulo inteiro

Vamos ao código:

1 import matematica
2
3 print matematica.somar(1,2)
4 print matematica.dividir(100,25)

Executando esse arquivo nós temos como resultado:

3 4

Note que ao importar o módulo inteiro é obrigatório usar o nome do módulo antes de suas funções, classes… Esse tipo de import evita problemas de namespace.

* Importando o que a gente quer do módulo

Esconder número das linhas

1 from matematica import somar, dividir
2
3 print somar(1,2)
4 print dividir(100,25)

O resultado é o mesmo do exemplo anterior:

3 4

A única diferença é que nós só importamos duas funções do módulo e não precisamos por “matematica” para chamá-los, ou seja, as duas funções importadas foram colocadas dentro do namespace do arquivo que está usando o módulo. Esse tipo de import é bom para módulos muito grandes em que só se use uma fcoisa ou poucas coisas dele, há um certo aumento de desempenho nesse caso e economia de memória.

* Importando tudo do módulo (diferente de importar o módulo inteiro)

1 from matematica import *
2
3 print somar(1,2)
4 print dividir(100,25)
5 print subtrair(10,8)

O resultado será:

3 4 2

É como o primeiro tipo de import, ele pega tudo do módulo, todas funções, classes, enfim. A diferença é que usando o “”"from modulo import *”"” eliminamos a necessidade de ficar digitando “matematica” toda vez que quisermos chamar algo do módulo.
Observações:

* Os arquivos de exemplo de uso do módulo devem estar na mesma pasta do módulo.
* Ao fazer módulos procure não deixá-lo tão grande. É uma boa prática de programação.

Adendo: Um módulo Python é como se fosse um pedaço de programa que você, como programador, decidiu que ficaria melhor separado do todo. Essa decisão geralmente é tomada sobre estruturas que são usadas em diversos programas. Isso facilita nossa vida, pois já não precisamos “copiar e colar” as coisas de um lado para outro. Claro, módulos podem ser mais complexos em certos pontos de vista. Eu mesmo não vejo nada de muita complexidade. Pura praticidade!
Módulos distribuídos com o Python

Com o Python, são distribuídos muitos módulos, para servem para diversos propósitos (antes escrever algo do zero, verifique se existe algo pronto nos módulos do Python)

Exemplos de módulos:

* os – suporte para recursos do sistema operacional (exemplos: mudar o diretório corrente e deletar arquivo)
* sys – rotinas que controlam o ambiente de execução do Python (exemplos: consultar o PYTHONPATH (lista de diretórios aonde o Python procura módulos) e encerrar o programa)
* copy – copia de objetos
* subprocess – rotinas para executar processos (incluso no Python 2.4)

Packages

O Package é uma maneira estruturar o namespace dos módulos através da notação do ponto. Por exemplo, web.forms é uma referência ao módulo forms que faz parte do package web.

Com packages, os autores de módulos não precisam se preocupar com a colisão de nomes.
Para criar um package:

* Crie um diretório (que terá o nome do package);
*

Crie um arquivo (que pode estar vázio) chamado __init__.py dentro do diretório;
* Coloque os módulos do package dentro do mesmo diretório.

Um módulo que faz parte de um package pode ser importado como import package.modulo ou from package import modulo.

Opcionalmente, o arquivo __init__.py pode inicializar uma lista chamada __all__, que contém quais módulos serão importados usando from package import *.
Classes

Criar uma classe em Python é muito simples. Acompanhe o exemplo: Esconder número das linhas

1 class Pessoa:
2   def __init__(self):
3     self.nome = “”
4     self.x = 0
5     self.y = 0
6   def andar(self, x, y):
7     self.y = self.y + y
8     self.x = self.x + x
9
10 eu = Pessoa()
11 eu.nome = “Cléber”
12 eu.andar(2, 0)

A classe criada chama-se Pessoa. É costume nomear classes DesteJeito em vez de deste_jeito. Assim, fica fácil de distinguir as classes dos objetos, das variáveis, das funções, etc. Essa convenção de nomenclatura é usada em Java, Ruby, Python e em outras linguagens (já que os programadores acabam levando esse costume de uma linguagem pra outra). Voltando à classe Pessoa.

Nela definimos duas funções (funções dentro classes geralmente são chamadas de métodos). A função andar, sob um ponto de vista muito abstrato, faz “a pessoa andar”, ou seja, altera os valores x e y de sua posição (faça de conta que também existe uma função pra desenhar a pessoa ). Perceba que eu não declarei nenhuma das variáveis. Classes servem mesmo é pra criar métodos (agrupar funções), e não tanto para criar estruturas de variáveis (apesar de classes em Python serem ótimos containers).

A função __init__() é especial: ela é chamada toda a vez que é criada uma nova instância da classe (obs.: instância de classe é o mesmo que objeto), por isso o nome init: ela inicializa o objeto, e é opcional. O argumento self é obrigatório, e deve ser o primeiro da função. Perceba que foi usado self na definição das variáveis. Isso quer dizer que estamos mexendo nas variáveis do objeto (Repare no detalhe: fora da classe usamos o nome do objeto criado, no caso eu. Dentro da classe, o código serve pra qualquer objeto criado a partir dessa classe, e o primeiro argumento, o self, representa o objeto sendo usado.).

Classes podem servir como os “struct” do C ou “record” do Pascal. dicts também podem servir como structs. dicts são mais usados pra simplesmente agrupar dados acessados por nome. Classes são mais usadas quando a estrutura é complexa, necessita de métodos de acesso e serão usadas várias instâncias da mesma estrutura. Pra simular uma struct, basta definir uma classe vazia, por exemplo:

1 class conteiner:
2    pass
3
4 # E depois criar as variáveis dela “por fora”,
5 conteiner.var = “fácil, não?”
6 conteiner.num = 1

O pass serve para indicar que nada precisa ser feito (porém a síntaxe exige que exista uma sentença naquele lugar)

Classes podem ser muito bem utilizadas, mas algumas vezes são péssimas opções. Assim como tudo em programação, saiba usá-las com parcimônia.

Exemplos, pra terminar:

1 class Carro:
2    def __init__(self, preco):
3       self.marca = “Ford”
4       self.modelo = “Maverick”
5       self.ano = 74
6       self.cor = [0,200,50]
7       self.pos = [0,0]
8    def andar(self, x, y):
9       self.pos[0] = self.pos[0]+x
10       self.pos[1] = self.pos[1]+y
11
12 carango = Carro(5000)   #passa o valor 5000 para __init__()
13
14 for i in range(300):
15    carango.andar(1,0)  #o carro anda 300m

Herança

Herança é um recurso poderoso da programação orientada a objetos que permite reutilizar o código de classes já definidas. Com a herança, é possível extender, especializar ou até mesmo fundir classes.

O Python suporta herança múltipla, ou seja, é possível criar uma nova classe a partir de várias outras (esse recurso deve ser usado com cuidado, pois isso pode criar dificuldades na manutenção)

Exemplo:

1 # definindo uma classe ‘pai’
2
3 class CD:
4   def __init__(self, titulo):
5     self.titulo = titulo
6
7   def mudarTitulo(self, novoTitulo):
8     self.titulo = novoTitulo
9
10 # definindo uma classe ‘filha’
11 # O nome da class ‘mãe’ (Na herança múltipla, os nomes das ‘mães’)
12 # é passado para a classe filha
13
14 class CDAudio(CD):
15
16   def __init__(self, titulo, autor):
17     CD.__init__(self, titulo)
18     self.autor = autor
19     self.faixas = []
20
21   def adicionarFaixa(self, numero, nome):
22     self.faixas.append((numero, nome))
23
24   def removerFaixa(self, numero, nome):
25     self.faixas.remove((numero, nome))
26
27 # Criando objeto
28
29 novoCD = CDAudio(‘Physical Graphitte’, ‘Led Zeppelin’);
30
31 # Evocando métodos:
32
33 novoCD.adicionarFaixa(1,’Custard Pie’)
34 novoCD.adicionarFaixa(2,’The Rover’)
35
36 # Listando a estrutura do objeto
37
38 print dir(novoCD)
39
40 # Acesando atributos
41
42 print “CD: %s, %s” % (novoCD.titulo, novoCD.autor)
43 print novoCD.faixas

Namespaces

Um Namespace é um dicionário com os nomes válidos em um programa durante a sua execução. Sendo assim, quando fazemos i = 1, o nome i é colocado em um namespace. O nome pode ser localizado de duas formas:

* Nome não qualificado
* Nome qualificado

Nomes não qualificados

Quando o nome da variável não foi qualificado (exemplo: i = 0, a busca é feita primeiro entre as variáveis locais (dica: para listar as variáveis locais: locals()), depois entre as variáveis globais (dica: para listar as variáveis globais: globals()) e por fim entre as variáveis pré-definidas do Python (builtins. Exemplos: True e False)
Nomes qualificados

Quando o nome da variável foi qualificado (exemplo: livro.pagina, a busca é feita primeiro no objeto, depois na classe do objeto e segue a hierarquia de herança.
List Comprehensions

List Comprehension é um nome pomposo para algo simples – uma construção que permite processar listas de uma forma bem próxima a matemática.

A sintaxe é [<expressão> for <variável> in <lista> if <condição>]

Aonde:

* <lista> é a lista original a ser processada;
* <variável> ítem da lista a ser processada;
* <expressão> expressão a ser aplicada em cada ítem;
* <condição> condição que deve ser cumprida para que o ítem seja processado.

A parte for <variável> in <lista> pode se repetir N vezes.

A condição é opcional.

Exemplo:

Esconder número das linhas

1 >>> # Multiplos de 4 entre 0 em 99:
2 …
3 >>> [x for x in range(100) if x % 4 == 0]
4 [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96]
5 >>>

Generators

Muitas vezes, em programação, é necessário processar listas de elementos. Porém, manter listas inteiras em memória, dependendo do tamanho, podem causar problemas de performance. Para isso, no Python, temos os Generators.

Na sintaxe, os generators são parecidos com as funções, porém existem algumas diferenças significativas:

* Um objeto do tipo generator retorna um elemento de cada vez quando evocado (através do método next
* O return habitual é substituido por yield
* Como os elementos são gerados apenas quando (e se) necessário, o resultado é menos consumo de recursos (isto é chamado Lazy Evaluation)

Exemplo:

1 >>> def getchar(word):
2 …     for c in word:
3 …         yield c
4 …
5 >>> pythonchars = getchar(‘Python’)
6 >>> pythonchars
7 <generator object at 0x009D5EE0>
8 >>> pythonchars.next()
9 ‘P’
10 >>> pythonchars.next()
11 ‘y’
12 >>> pythonchars.next()
13 ‘t’
14 >>> pythonchars.next()
15 ‘h’
16 >>> pythonchars.next()
17 ‘o’
18 >>> pythonchars.next()
19 ‘n’
20 >>>

Generator Expressions

Generator Expressions (também chamadas de Genexps) são o equivalente a List Comprehensions para se criar Generators.

A sintaxe é semelhante a da List Comprehension, porém, numa Generator Expression se usa () (parantesis) para delimitar a expressão, ao invez de [] (colchetes) como na List Comprehension.

Uma Generator Expression pode ser vista também como a versão Lazy Evaluated da List Comprehension, já que cada elemento é gerado apenas quando necessario, e não todos de uma vez.

Exemplo (baseado num post de Guido Van Rossum em seu blog):

1 >>> # funções uteis para usar com genexps
2 >>> def any(S):
3 …    for x in S:
4 …         if x:
5 …            return True
6 …    return False
7 …
8 >>> def all(S):
9 …     for x in S:
10 …         if not x:
11 …            return False
12 …     return True
13 …
14 >>> S = [42, 42]
15 >>> # Usando Genexps
16 >>> any(x > 42 for x in S)     # True se algum elemento de S for > 42
17 >>> all(x != 0 for x in S)     # True se todos os elemtos de S forem diferentes de zero

Um exemplo Completo

Pretendo deixar um aplicativo de exemplo para sintetizar tudo. Uma idéia que me ocorreu agora é fazer um programinha gráfico (usando tk) de perguntas e repostas (quiz). Não sei se é confundir muito botar tk no meio, mas creio que se a pessoa entendeu o tutorial vai ser capaz de entender um pouco do código, mesmo porque com o quiz eu posso usar dicionários, listas, abrir/fechar arquivos (aka usar módulos), talvez usar classes e mostrar um exemplo prático que teoricamente rodaria em todas as plataformas.

(Sugestão: Coloca o programa sim! Assim o tutorial “cresce” junto com o leitor, em vez de ficar só no conhecimento básico – tem é que mergulhar fundo! Ao infinito e além!!)

(Muito bom! Este exemplo completo seria muito interessante. De repente não utilizar a biblioteca gráfica, para não complicar, tendo em vista que a sintaxe do Python é bem particular, não tendo muitas semelhanças com as linguagens de uso corriqueiro)

(Po! Eu acho legal colocar o exemplo de quiz… ia simplificar muito o aprendizdo, visto que editar codigo eh um otimo aprendizado…)

(Acho que toolkits gráficos atrapalham para quem está aprendendo (até porque tem toneladas deles). Seria legal ter um tutorial só de tk com o programa completo. Pessoalmente, preferia que fosse PyGTK…)

(Eu tenho um pouco de experiencia com PyGTK, mas poderiamos fazer um no console tambêm. ~YuriSchlesner)

(Se esta página e´sobre uma introdução em Python nada mais justo que usar algo fraquinho como Tkinter. Andrik Machado Batista)

(Se Tkinter é fraquinho, portanto não muito útil, então porque não algo mais prático? Interface Web, por exemplo)

(Outra coisa – não seria melhor separar a página em partes? Ela está ficando um pouco grande…)
Próximos passos

Existem muitos caminhos para continuar aprendendo Python. Algumas possibilidades são:

* Esse próprio site (PythonBrasil)
* A documentação oficial do Python, em inglês (Python 2.4.1 Documentation)

No related posts.

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

A validação é importantíssima, pois sem ela, o programa pode trabalhar com dados inválidos, e muitos problemas podem acontecer:

Resultados inesperados

Se o programa pede, por exemplo, um número entre 1 e 100, o usuário entra com 200, e o programa não faz essa checagem, pode acabar utilizando o número em alguma conta e terminando com um resultado inválido. Segurança

Um dos problemas mais graves da falta de checagem, quando por exemplo a entrada do usuário é utilizado diretamente em uma query SQL ou como parâmetro de um comando. Os dados entrados pelo usuário podem manipular a query ou o comando e conseguir acesso não autorizado ao banco de dados ou ao servidor.

Dados inconsistentes

Se, por exemplo, em um campo onde deveria se entrar um CEP, o usuário coloca números inválidos, letras, ou deixa em branco, o a empresa terá problemas, por exemplo, para enviar uma mala direta postal para seus clientes.

No caso de aplicações em PHP, com a saída via web, a validação ainda deve ser feita, preferencialmente, duas vezes: uma do lado do cliente (em Javascript) para se evitar que os dados inválidos sejam enviados, e outra do lado do servidor (em PHP), para evitar que dados inválidos tenham sido enviados por um navegador sem Javascript (ou com o Javascript desligado), ou maliciosamente por alguem. A validação em Javascript foge do escopo deste artigo, que irá tratar da validação dos dados em PHP.

A classe PEAR Validate

Sempre que possível, devemos evitar reescrever código já disponível, principalmente quando o código já disponível é de qualidade, como acontece com a maioria das classes disponíveis no PEAR, que devem seguir uma padronização de código bem rigorosa para serem aceitas.

Uma das classes disponíveis no PEAR é a Validate, que é uma classe genérica para validação de dados. A classe pode validar os seguintes tipos de dados:

   * Números, podendo-se especificar valor mínimo e máximo, e número de casas decimais;
   * Emails, checando a sintaxe do email, se o domínio é válido, e se o email está no formato da RFC 822;
   * Strings, com constantes pré-definidas para facilitar a validação de maiúsculas e minúsculas, tamanho da string, entre outras;
   * Datas, com checagem de data mínima e máxima, e se o formato é RFC 822;
   * URLs, checando se o formato é válido (de acordo com a RFC 2396).

A utilização é bastante simples. Uma vez instalada (é apenas um arquivo, chamado Validate.php), basta chamar estaticamente seus métodos, passando o dado a ser validado como primeiro parâmetro, e as opções de validação (quando aplicáveis) como segundo parâmetro. Os métodos retornam true ou false, indicando se a validação passou ou não.

Por exemplo, para validar um número em $num como sendo um número de 0 a 100 com no máximo 2 casas decimais, a chamada seria a seguinte:

 <?php
 $opt = Array('decimal' => '.',
              'dec_prec' => 2,
              'min' => 0,
              'max' => 100);
 if (Validate::number($num, $opt)) {
     // validação ok!
 }
 ?>

Os outros métodos são semelhantes, e para se saber quais são as opções que podem ser passadas, basta olhar os métodos disponíveis diretamente na documentação da classe, ou então diretamente dentro do arquivo da classe.

A classe PEAR Validate_ptBR

Assim como a classe Validate provê métodos úteis para a validação de dados genéricos, temos também disponível a classe Validate_ptBR, que disponibiliza métodos para validação de dados específicos do Brasil. A classe valida os seguintes tipos de dados:

   * CEP, com 8 dígitos;
   * CPF, checando se os dígitos verificadores correspondem ao restante do número;
   * CNPJ e PIS, também usando a checagem de dígitos verificadores;
   * Estados brasileiros (siglas);
   * Números telefônicos, com ou sem código de área;
   * Placas de carros, com 3 letras e 4 dígitos.

A utilização da classe é semelhante à classe Validate, bastando chamadas estáticas aos seus métodos. Assim como na classe Validate, para saber os métodos disponíveis e seus parâmetros, basta examinar a documentação da classe.

Por: Flávio Silva

Related posts:

1. Como Trabalhar com Funções em PHP Olá, nesse artigo vamos abordar o tema Funções definidas pelo...
2. Introdução a Linguagem PHP O que é o PHP? PHP significa “Hypertext Preprocessor”, e...
3. Redirect em PHP Para fazer com que o usuário ao acessar um determinado...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Através dos repositórios (Ubuntu)

sudo apt-get install postgresql-8.3

Com isso teremos a versão 8.3 instalada em pouco tempo. O Ubuntu irá buscar o postgresql em seus servidores e o instalará e configurará para nós.

Detalhes

Diretório de dados – /var/lib/postgresql/8.3/main/base
Diretório do pg_hba.conf e do postgresql.conf – /etc/postgresql/8.3/main autovacuum.conf – /etc/postgresql-common pg_dump, pg_dumpall, psql e outros binários – /usr/bin

Acessando pelo prompt

Acessando a console psql
sudo -u postgres psql

No primeiro acesso trocar a senha do usuário postgres:

alter role postgres password ‘postgres’;

Para poder acessar com o PGAdmin.

Parece que por uma questão de segurança, o usuário postgres não tem acesso pela console, mas caso queira que o mesmo acesse então …

Trocar a senha do super-usuário

sudo passwd postgres

Instalando através dos Fontes

Este método de instalação dá um pouco mais de trabalho mas em contrapartida é o que oferece um maior controle e uma maior possibilidade de customização.

Pré-requisitos para instalação do PostgreSQL num UNIX:

make do GNU (gmake ou make)
compilador C, (preferido GCC mais recente)
gzip
biblioteca readline (para psql)
gettext (para NLS)
kerberos, openssl e pam (opcionais, para autenticação)

Veja como instalar esses requisitos no Ubuntu:

sudo apt-get install build-essential libreadline5-dev zlib1g-dev gettext

Obs.: estes pacotes podem mudar de nome devido ao aparecimento de novas versões. E use make ao invés de gmake.

Download – http://www.postgresql.org/ftp/source/

Descompacte em /usr/local/src e instale no diretório default, que é /usr/local/pgsql.

sudo tar zxpvf postgresql-8.3.1.tar.gz -C /usr/local/src

cd /usr/local/src/postgresql-8.3.1

Caso já tenha o postgresql instalado no Ubuntu, pule as etapas de criação do grupo e do usuário na instalação abaixo, como também terá que alterar a porta no script postgresql.conf, logo após a criação do cluster com o comando initdb e, no caso, os comandos deverão passar também a porta, por exemplo:

bin/createdb -p 5433 bdteste

bin/psql -p 5433 bdteste.

Configurar, Compilar e Instalar

sudo ./configure
sudo make
sudo make install
sudo groupadd postgres
sudo useradd -g postgres -d /usr/local/pgsql postgres
sudo mkdir /usr/local/pgsql/data
sudo chown postgres:postgres /usr/local/pgsql/data
sudo passwd postgres
su – postgres
bin/initdb -D /usr/local/pgsql/data
bin/pg_ctl -D /usr/local/pgsql/data start
bin/createdb teste
bin/psql teste

Isso irá criar um cluster com encoding UTF-8 (default do Ubuntu)

Caso prefira iso-8859-1, antes de executar o initdb, exporta a variável LANG:
export LANG=pt_BR.iso-8859-1
bin/initdb –encoding latin1 -D /usr/local/pgsql/data

Copiar o script de inicialização “linux” para o /etc/init.d
sudo cp /usr/local/src/postgresql-8.3.0/contrib/start-script/linux /etc/init.d/postgresql-8.3.0

Dar permissão de execução ao script
sudo chmod u+x /etc/init.d/postgresql-8.3.0

Adicionar ao Path
su – postgres
gedit /etc/bash.bashrc (e adicione a linha abaixo):
PATH=/usr/local/pgsql/bin:$PATH

Fonte: http://postgresql.ribafs.org/

Related posts:

1. Introdução ao PostgreSQL Resumo da História do PostgreSQL É um poderoso SGBD com...
2. OpenDNS: Configurando o uso dos servidores no seu computador: Linux O Linux possui vários utilitários gráficos para a configuração de...
3. Instalação do ClamAV com DazukoFS Introdução // O ClamAV é um dos mais conhecidos antivírus...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

O PostgreSQL atual é derivado do POSTGRES, escrito pela universidade de Berkeley na Califórnia EUA). O POSTGRES foi inicialmente patrocinado pela Agência de Projetos de Pesquisa Avançados de Defesa (DARPA), pelo Escritório de Pesquisa sobre Armas (ARO), pela Fundação acional de Ciências (NSF) e pelo ESF, Inc.

PostgreSQL é o trabalho coletivo de centenas de desenvolvedores, trabalhando sob vinte-um anos e desenvolvimento que começou na Universidade da Califórnia, Berkeley. Com seu suporte de onga data a funcionalidades de nível corporativo de bancos de dados transacionais e escalabilidade,
o PostgreSQL está sendo utilizado por muitas das empresas e agências de governo mais exigentes.
O PostgreSQL é distribuído sob a licensa BSD, que permite uso e distribuição sem ônus para plicações comerciais e não-comerciais.

POSTGRES – 1986
POSTGRES 1 – 06/1989
POSTGRES 2 – 06/1990
POSTGRES 3 – 06/1991

O Informix (adquirido pela IBM) foi originado do código do POSTGRES
Em 1994 Andrew Yu and Jolly Chen adiciona um interpretador de SQL substituindo o PostQUEL
Ele muda de nome para Postgres95 e tve seu código completamente reescrito em ANSI C

Postgres95 – 01/05/1995
PostgreSQL 1 – 05/09/1995

Em 1996 muda novamente de nome, agora para PostgreSQL
PostgreSQL 6 – 29/01/1997 (do 1.09 passou para o 6)
PostgreSQL 7 – 08/05/2000
PostgreSQL 8 – 19/01/2005 (primeira versão for Windows)
PostgreSQL 8.1 – 08/11/2005
PostgreSQL 8.2 – 05/12/2006
PostgreSQL 8.3 – 04/02/2008 (versão atual)

Uma nova versão sai aproximadamente a cada ano.

Fontes:
http://www.postgresql.org/docs/8.3/interactive/release.html
http://www.postgresql.org/docs/8.3/interactive/history.html

Características Avançadas do PostgreSQL
- Exporta em XML
- Busca Textual, com TSearch2
- Novos tipos de dados: ENUM e matrizes de tipos compostos
- Suporte a SNMP
- Transações
- Replicação
- Banco de dados objeto-relacional
- Suporte a transações (padrão ACID)
- Lock por registro (row level locking)
- Integridade referencial
- Número ilimitado de linhas e índices em tabelas
- Extensão para GIS (base de dados geo-referenciados)
- Acesso via drivers ODBC e JDBC
- Interface gráfica de gerenciamento
- Uso otimizado de recursos do sistema operacional
- Suporte aos padrões ANSI SQL 92 e 99
- Joins: Implementa todos os tipos de join definidos pelo padrão SQL99: inner join, left, right, full uter join, natural join.
- Triggers, views e stored procedures
- Suporte ao armazenamento de BLOBs (binary large objects)
- Sub-queries e queries definidas na cláusula FROM
- Backup online
- Sofisticado mecanismo de tuning
- Suporte a conexões de banco de dados seguras (criptografia)
- Modelo de segurança para o acesso aos objetos de banco de dados por usuários e grupos de suários

Suporte aos tipos de dados SQL92 e SQL99, incluindo INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE, INTERVAL e TIMESTAMP. Também suporta armazenamento de binary large objects, incluindo imagens, sons ou vídeo. Tem interfaces de programação nativa para C/C++, PHP, Java, .Net, Perl, Python, Ruby, Tcl, ODBC,

Fonte: site do Dextra Treinamentos
Lista completa: http://www.postgresql.org/about/press/features83 e
http://www.postgresql.org/docs/8.3/static/release-8-3.html

Limites do PostgreSQL

Licença
O PostgreSQL usa a licença BSD, que apenas requer que o código fonte sob licensa mantenha o seu ireito de cópia e a informação da licensa. Essa licensa certificada pela OSI é amplamente vista omo flexível e amigável a empresas, já que ela nao restringe o uso do PostgreSQL com aplicações
comerciais e proprietárias. Juntamente com suporte de várias empresas e propriedade pública do ódigo, a licensa BSD torna o PostgreSQL muito popular entre empresas que querem embutir o anco de dados nos seus próprios produtos sem temor de taxas, enclausuramento a uma empresa, ou udanças nos termos da licença.

Sistemas Operacionais Suportados
Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64) e Windows.

Quem oferece Suporte ao PostgreSQL no Brasil
- Carlos Smanioto (Bauru)
- dbExperts (SP)
- Dextra (Campinas)
- Flexsolutions Consultores (Goiânia)
- Locadata (Belo Horizonte)
- Mosman Consultoria e Desenvolvimento (São Pedro – SP)
- Studio Server Hospedagem de Sites (Santos)

Detalhes e Lista completa: http://www.postgresql.org/support/professional_support_southamerica

Oferecem Suporte ao PostgreSQL (consultores individuais e empresas):
Lista completa: http://www.postgresql.org/support/professional_support

Mais empresas e consutores que oferecem suporte ao PostgreSQL:
http://www.opensourcexperts.com/Index/index_html/PostgreSQL/index.html

Algumas Empresas que Patrocinam o PostgreSQL
- InterpriseDB
- Fijitsu
- RedHat
- Skype
- Sun

Lista completa – http://www.postgresql.org/about/sponsors
Algumas Empresas que usam o PostgreSQL (internacionais)
- Apple
- BASF
- Cisco
- OMS (Organização Mundial de Saúde)

Algumas Empresas que usam o PostgreSQL (nacionais)
- FAB (Força Aérea Brasileira)
- Prefeitura Municipal de Sobral
- Vivo
- DNOCS
- DETRAN do Ceará

Equipe de Desenvolvimento do PostgreSQL
http://www.postgresql.org/community/contributors/
Comunidade Brasileira
http://www.postgresq.org.br

Fonte: http://postgresql.ribafs.org

Related posts:

1. Instalação do PostgreSQL no Linux Numa instalação no Linux, mesmo com a versão 8.3.6, podemos...
2. Introdução ao Linux O Linux é um sistema operacional, ou seja, a interface...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Nesse artigo vamos demonstrar a integração do servidor web Apache com o servidor JSP Tomcat. Demonstrarei como instalar,configurar e integrar as switches, essa artigo foi baseado na distro debian, Apache2 e Tomcat5.

Preparando a instalação

Antes de começarmos a insatalação devemos adionar ao nosso source.lits os seguintes repositórios:

### Tomcat5 ####
deb http://www.gallet.info.free.fr/debian/ sarge contrib main non-free

### JDK ###
deb http://www.linex.org/sources/linex/debian sarge linex

### PHP5 ###
deb http://people.debian.org/~dexter all sarge

Salve saia e atualize o aptitude.
# aptitude update

 Instalando os Pacotes
Apache: # aptitude install apache2
Tomcat : # aptitude install tomcat5 tomcat5-examples tomcat5-admin
Mod_JK2 :# aptitude install libapache2-mod-jk2
JDK: # aptitude install  j2sdk1.4
J2SE: aptitude install  j2se-common
PHP5: # aptitude install php


Configurando J2SDK

Vamos editar o arquivo /etc/profile adicionando nela as seguintes variáveis de ambiente:
CATALINA_HOME=/usr/lib/j2re
TOMCAT_HOME=/usr/lib/j2re
JAVA_HOME=/usr/lib/j2se/1.4
Após digitar salve e saia e faça com que o profile seja carregado:
#source /ect/profile

Configurando usuários no Tomcat

Para podermo acessar a área adminsitrativa do nosso servidor tomcat, devemos alterar o arquivo tomcat-users.xml que fica no diretório: /var/lib/tomcat5/conf
#vi /var/lib/tomcat5/conf/tomcat-users.xml
Vamos remover todo o seu conteúdo, adicionando as seguintes entradas:
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="admin" password="1234" roles="admin,manager"/>
</tomcat-users>

Onde myadminpass deve ser subistituído por uma senha de sua preferencia.

Configurando Tomcat

Agora vamos copiar o arquivo workers2.properties, que se enconta na pasta /usr/share/doc/libapache2-mod-jk2/examples/, para a pasta /etc/tomcat5
# cp /usr/share/doc/libapache2-mod-jk2/examples/workers2.properties /etc/workers2.properties


Fazendo apache e o Tomcat  responderem na mesma porta

Como sabemos , o apache funciona na porta 80, já o tomcat funciona na porta 8080.
Devemos então fazer que as requizições que cheguem na porta 80 sejam direcionadas para a porta 8080 de forma tranasparente, para isso temos duas possibilidades, a primeira criar um redirecionamento com iptables:
iptables -A FORWARD -s ip_ser_tomcat -p tcp --dport 80 -j REDIRECT 8080
iptables -A FORWARD d ip_ser_tomcat -p tcp --sport 80 -j REDIRECT 8080
Com isso o iptables vai redirecionar todas as conexões que chegarem na porta 80 para a 8080, só que eu testei uma outra forma que eu particularmente gostei mais, vamos criar um proxy reverso, ele vai fazer exatamente o mesmo que o iptables, redirecionar as conexões destinadas a porta 80 para a 8080. 

Primeitamente temos que habilitando o módulo proxy:
ln -s /etc/apache2/mod-available/proxy.load /etc/apache2/mod-enable

Habilitando o módulo rewrite
ln -s /etc/apache2/mod-available/proxy.load /etc/apache2/mod-enable

Adicione as seguinte linhas no apache2.conf (/etc/apache2/apache2.conf)                                                                    
  ProxyPass       /jsp-examples      http://localhost:8080/jsp-examples
  ProxyPassReverse /jsp-examples     http://localhost:8080/jsp-examples
Salve o arquivo e saia

Inicie o Tomcat e o Apache (nessa ordem, primeiro o tomcat e enseguida o apache)

Adicione a seguintes linhas ao arquivo server.xml (/etc/tomcat5/server.xml)
 <Connector port="8081" ...
              proxyName="www.mycompany.com"
              proxyPort="80"/>


 Testando

http://localhost/jsp-examples



 Agradecimentos

http://www.apache.org
http://tomcat.apache.org/
http://tomcat.apache.org/faq/



 Autor

Leandro Moreira

Related posts:

1. Integração simples do Apache 2 com Tomcat 5 Tutorial Basico de integração do Apache 2 com Tomcat. Instalando...
2. Compilar PHP + PDO OCI com instantclient Segue abaixo uma forma rápida e prática para se ativar...
3. Tutorial Tomcat – Instalação e Configuração Básica Nota: Na revisão 13 deste tutorial, o conteúdo foi bastante...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Ligando e Desligando a Máquina

Salvo orientação específica do hardware em uso, ligar uma máquina Unix não costuma envolver maiores detalhes do que o acionamento de um botão liga/desliga no console da máquina e uma eventual intervenção humana logo em seguida, solicitando o boot efetivo do sistema a partir de um menu de opções.

O boot costuma gerar uma razoável quantidade de mensagens que aparecem no console da máquina. Normalmente elas referem-se aos diferentes estágios do reconhecimento e inicialização do hardware. É interessante conhecê-las, não obstante, salvo contingências, podem ser ignoradas até que surja o prompt ou a janela de login.

O desligamento é um processo mais delicado. O Unix utiliza parte da memória principal como cache de disco, a fim de acelerar as operações de leitura e gravação de arquivos. Antes de se desligar a máquina, é necessário assegurar que os discos estejam sincronizados com o cache, o que é feito pelo comando sync, que deve ser precedido do encerramento de todos os processos, a fim de que não ocorra uma dessincronização em seguida. Todos esses passos são tomados pelo comando shutdown:

$ shutdown -y -g 1 -i 5 (Solaris)
$ shutdown -h now (Linux)

Em sistemas baseados em PC, o shutdown por vezes é acionável através do ctrl-alt-del.

Manipulando arquivos e diretórios

O shell é o programa que lê e executa os comandos que você passa a digitar logo após logar no sistema, como cd ou ls. Via de regra você estará usando o Bourne shell (sh), ou o C shell (csh), ou aperfeiçoamentos desses, como o Korn shell (ksh) ou o Bourne again shell (bash). Via de regra você poderá descobrir qual deles está usando ao executar um ps ou um finger com o seu username com argumento.

Obsoleta ou não, a interface de linha de comandos possui características ainda não suficientemente reproduzidas nas interfaces gráficas, como a possibilidade de uso remoto com baixa banda, e a programabilidade. No caso do Unix, há ainda a vantagem dela estar melhor estandardizada que as interfaces gráficas. Em boa parte dessas notas estaremos nos referindo à interface de linha de comandos, mas abordaremos também a interface gráfica ao final. Vejamos alguns típicos comandos dos sistemas Unix-like:

• cat [-r] arquivo1 arquivo2 ... 

  Concatena os vários arquivos, na ordem especificada, copiando o resultado para a saída padrão. Se não houver argumentos, copia a entrada padrão para a saída padrão.

• cd diretório

  Troca o diretório corrente para o diretório especificado, ou para o diretório home, se não houver argumento.

• cp [-r] argumento1 argumento2 ... 

  Copia um ou mais arquivos, trocando seu nome ou criando a cópia num outro diretório, conforme a quantidade e o tipo dos argumentos. Se o primeiro argumento for um diretório, faz uma cópia recursiva de toda a subárvore iniciada nele, desde que a opção -r (recursive) tiver sido especificada.

• chmod nnn argumento1 argumento2 ... 

  Troca os atributos do(s) argumento(s) para nnn (veja atributos de arquivos). Ao invés de nnn, a alteração pode ser especificada por exemplo como a+r ou g-w (a, g e o significam all, group e owner; + significa adicionar e - remover; r,w, x e s indicam respectivamente atributos de leitura, escrita, execução e setuid).

• ls [-la] diretório1 diretório2 ... 

  Lista o conteúdo do(s) diretório(s) especificado(s), ou do diretório corrente se não houver argumento. Opções principais:
  -a Inclui arquivos com nome iniciado por “.” (tais arquivos normalmente armazenam configurações de aplicativos).
  -l Formato longo (veja atributos de arquivos).
  

• ln -s argumento1 argumento2 

  Cria um link simbólico cujo nome é o primeiro argumento, apontando para o segundo argumento. A opção -s não pode ser omitida, ou o link criado será um hard link, ao invés de simbólico.

• man [-k] nome 

  Invoca a man-page associada ao nome, ou exibe uma lista das man pages associadas ao nome, no caso da opção -k (de key) ter sido especificada.

  As man pages Unix são referências técnicas sumárias por vezes difíceis de compreender. Elas são exibidas através do more ou de algum outro paginador semelhante, por isso os comandos do more indicados mais adiante valem para a leitura de man pages, e são úteis para ajudar a localizar informações dentro de uma man page.

  As man pages são divididas em seções, que tradicionalmente são referidas através de parênteses. Por exemplo, a man page shutdown(2) é a man page do system call chamado shutdown, ao passo que a man page shutdown(8) é a man page do comando administrativo shutdown. Além dessas, a seção 1 contém manuais de comandos comuns, a 3 contém manuais de serviços de bibliotecas, a 4 descreve device special files, a 5 descreve formatos de arquivos de configuração, a 6 os jogos eventualmente instalados, e a 7 contém tudo o mais que não couber nas anteriores.

• mkdir diretório1 diretório2 ... 

  Cria os diretório(s) especificado(s).

• more arquivo 

  Exibe de forma paginada o arquivo especificado, ou a entrada padrão no caso de não haver argumento. Aceita vários comandos, entre eles
  

  ESPAÇO, C-b / ?

  Avança/recua uma página. Busca. Exibe relação de comandos.

• mv argumento1 argumento2

  Renomeia o primeiro argumento, que pode ser um arquivo ou um diretório, para o nome dado como segundo argumento. Se ao tentar executar esse comando a mensagem de erro cannot move across filesystems for exibida, é porque a origem e o destino estão em filesystems diferentes. Nesse caso deve-se copiar a origem para o destino usando cp, e depois remover a origem com rm.

• rm [-r] argumento1 argumento2 ... 

  Remove os arquivo(s) especificado(s). Se um argumento for um diretório, remove toda a subárvore iniciada nele, desde que a opção -r (recursive) tenha sido especificada. Via de regra não há modo em sistemas Unix-like de recuperar (undelete) um arquivo removido.

• rmdir diretório1 diretório2 ... 

  Remove os diretório(s) especificado(s), desde que estejam vazios.

• vi arquivo 

  O vi é uma ferramenta obsoleta, mas está está presente em virtualmente qualquerr plataforma Unix-like, e constitui por vezes a única alternativa para edição de arquivos, por isso convém conhecê-lo ao menos de forma minimal. No uso quotidiano, entretanto, normalmente preferir-se-á outras ferramentas, como o emacs ou o pico ou outras.

  h, j, k, l C-f,C-b x,X [n]dd i,ESC a,A J :

  cursor para esquerda/baixo/cima/direita. Página seguinte/anterior. Remove caracter atual/anterior. Remove n linhas (default 1). Entra/sai do modo inserção. Insere após caracter atual/final da linha. Concatena linha seguinte à atual. entra comando, entre eles w (salva), q (sair) e / (busca).

• wc arquivo1 arquivo2 ... 

  Obtém o total de linhas, palavras e caracteres de cada um dos arquivos estipulados, ou da entrada padrão no caso de não haver argumentos.

Shell Scripts

Seqüências de comandos que se necessita repetir com grande frqüência podem ser colocados num arquivo que, ao ser “executado”, ocasiona o disparo de cada um dos comandos da seqüência, na ordem indicada. Um arquivo desses é um shell script, cujo equivalente no MS-DOS são os arquivos “.BAT”.

Mesmo que nunca se escreva nenhum, com certa freqüência é necessário analisar shell scripts a fim de elucidar o modo de uso de determinados comandos, ou de realizar diagnósticos. Suponhamos por exemplo que você não se lembre como usar um comando chamado xpatgen, mas esteja com um shell num diretório que contém scripts, que usam entre outros o xpatgen. Basta então buscar ocorrências dele nos scripts:

$ grep xpatgen *
patgen: xpatgen -cal_bl

Com isso sabemos que o script patgen executa o xpatgen, e relembramos o modo de executar esse comando, o que talvez já seja suficiente para a necessidade do momento.

Shell scripts utilizam com freqüência de variáveis de environment e de parâmetros de linha de comando. Assim, se ao analisar um script você se deparar com algo como $HOST, lembre-se de que nesse ponto será substituído o valor da variável HOST, e que $1 significa o primeiro parâmetro da linha de comandos, $2 o segundo, e assim por diante.

Variáveis de Environment

Além dos parâmetros de linha de comandos como -l ou outros, pode-se também passar parâmetros a um programa através do uso de variáveis de environment. As mais comuns são:

• PATH – Lista os diretórios (separados por “:”) onde os executáveis serão procurados, tipicamente /bin, /usr/bin e /usr/X11/bin, entre outros.
• TERM – Tipo do terminal, por exemplo xterm ou vt100 (veja Configurando o Terminal).
• DISPLAY – Display default para as aplicações Xwindows.

Para exibir o valor de uma delas pode-se usar echo, antepondo o operador $ ao nome da variável, por exemplo:

$ echo $TERM

Existem dois estilos de atribuição de valores a variáveis de environment, o do Bourne shell, usado pelo sh, ksh e bash:

$ TERM=vt100; export TERM

e o do C shell, usado pelo csh e pelo tcsh:

% setenv TERM vt100

Uso de Metacaracteres

O metacaracter mais utilizado provavelmente é o “*”. Por exemplo,

$ rm *

irá remover todos os arquivos do diretório corrente. É necessário prestar atenção a dois detalhes quando se usa metacaracteres:

1. O caracter “.” não tem o significado de separador entre nome e sufixo que possui no MS-DOS, por isso “*.*” significa todos os arquivos em cujo nome ocorre ao menos um ponto.

2. A expansão do metacaracter é feita pelo shell, e não pela aplicação, por isso o comando

   $ mv *.txt *.bak

   não irá surtir o efeito esperado de renomear todos os arquivos que terminam com “.txt” para “.bak” (para essa operação deve-se usar o comando for).

Os shells Unix aceitam também o metacaracter “?”, que significa qualquer caracter e tambem intervalos, como [0-9] (qualquer dígito decimal), entre outros.

Uso de Expressões Regulares

Aplicativos Unix via de regra aceitam expressões regulares como argumentos de busca. Os usos mais freqüentes delas são bem ilustrados através do aplicativo grep. Nos casos abaixo ele será utilizado para buscar uma dada expressão em todos os arquivos do diretório corrente:

1. Busca de ocorrências de algum dos anos da década de 80:

   $ grep "198[0-9]" * 

2. Busca de uma ocorrência da palavra “yellow” seguida de uma ocorrência da palavra “page”, separadas por zero ou mais caracteres quaisquer:

   $ grep -i "yellow.*page" * 

3. Busca de uma das palavras “roget” ou “thesaurus”:

   $ grep -i "roget\|thesaurus" * 

A sintaxe das expressões regulares pode variar um pouco, dependendo da plataforma e da ferramenta. Via de regra as diferenças consistem em proteger-se ou não alguns caracteres especiais, e nas extensões que algumas ferramentas introduzem. Note por exemplo, o uso do egrep, em comparação com o uso do grep acima:

$ egrep -i "roget|thesaurus" * 

Via de regra todas as ferramentas Unix que lidam com texto, como o more, o sed, e o vi, entre outros, aceitam expressões regulares como argumento de buscas.

Manipulando processos

Um processo é um programa em execução. Num computador que possui apenas uma cpu, na verdade apenas um processo pode estar sendo executado em cada instante. O que se faz é executar um processo durante uma fração fixa de segundo, congelá-lo e passar a executar um outro, e assim por diante, criando a ilusão de simultaneidade.

Através do comando ps pode-se examinar os processos correntes. Por exemplo:

$ ps
PID TTY STAT TIME COMMAND
45 v02 S 0:00 -bash
105 v02 R 0:00 ps

O ps em geral omite muitos processos a fim de exibir uma saída limpa. Através das opções a e x (ou e no Solaris), pode-se exibir todos os processos correntes. O número de um processo é usado, por exemplo quando é necessário interromper prematuramente a sua execução, através do comando kill.

A finalidade primária do comando kill não é matar um processo, mas enviar um sinal para ele. O Unix possui diversos sinais predefinidos, como SIGHUP, SIGPIPE, SIGTERM, etc. O atendimento a um sinal entretanto é responsabilidade do processo, ou do programador que fez o programa, e por isso a forma com que cada processo reagirá a cada sinal poderá variar. A fim de se interromper a execução de um processo, deve-se enviar para ele o sinal SIGKILL:

$ kill -SIGKILL 45
$ kill -9 45

As duas formas acima em geral são equivalentes (o número associado a cada sinal pode variar com a plataforma).

O caracter “&” colocado ao final da linha de comandos instrui o shell para disparar o comando em background, a fim de que se possa continuar usando o shell mesmo antes desse comando encerrar a sua execução.

O comando nice faz com que um processo seja disparado com baixa prioridade.

 $ nice gzip -9 *

O comando nohup faz com que o processo sendo disparado se torne imune ao sinal SIGHUP. Em combinação com o &, ele permite o disparo de programas que permanecerão em execução mesmo após o logout do usuário. Exemplos:

 $ nohup gzip -9 * &

Através do comando at pode-se programar a execução de um comando para um horário determinado. Por exemplo:

$ at now + 1 minute
ls
ctrl-d

O comando ls será dessa forma executado daqui a um minuto. Note que na linha seguinte do comando at o que se escreve é na verdade um shell script, terminado com control-d. Ao invés de digitá-lo, poder-se-ia lê-lo de um arquivo através do redirecionamento da entrada:

$ at now + 1 minute <meuscript 

A execução periódica de um comando se faz através do cron, que é disparado no boot do sistema e monitora as tabelas de execução periódica de comandos de todos os usuários (a cada usuário corresponde uma tabela). Uma tal tabela é chamada crontab. Através dela pode-se especificar que um comando seja executado a cada hora, ou diariamente, ou semanalmente, etc. A edição, inspeção e remoção da crontab de um usuário é feita através do comando crontab, e opções -e, -l e -d. Cada linha da crontab indica um comando e a periodicidade com que ele deve ser executado (minutos, horas, dias do mês, meses e dias da semana). Por exemplo:

$ crontab -l
40 07 * * * updatedb
0 22 5 * * pagamento
0 6,12,15,18 * * * fetch
0 0 * * 6 backup

No caso a crontab contém três comandos. O updatedb deverá ser executado todos os dias às 7:40. O comando pagamento deverá ser executado às 22:00 do dia 5 de cada mês, e o backup será executado à zero hora de cada sábado.

Note que a crontab é um arquivo texto simples, e quando se executa o comando crontab com a opção -e, entra-se num editor de textos para editá-la. O editor de textos utilizado normalmente será o vi, ou aquele especificado na variável de environment EDITOR.

Configurando o terminal

O terminal pode ser um terminal no sentido estrito do termo, conectado ao computador por uma linha serial, ou então o próprio console da máquina, ou uma aplicação como o xterm emulando um terminal dentro do Xwindows,

A configuração do terminal é necessária para executar aplicativos como editores de texto visuais, ou para os comandos de teclado como backspace serem corretamente reconhecidos. Essa configuração envolve a configuração do driver do sistema, feita através do comando stty e o informe da aplicação, normalmente feito através da variável TERM. Vejamos exemplos de situações onde uma delas ou ambas são necessárias, e como realizá-la:

1. Ao pressionar a tecla backspace, ao invés de ser apagado o caracter anterior, surge na tela os caracteres “^H”. Solução:

   $ stty erase ^H

2. Ao executar o more ou o vi, algumas linhas permanecem escondidas, ou o scroll comporta-se de forma errática. Solução: cheque quantas linhas (vamos supor: 24) e quantas colunas (vamos supor: 80) o seu terminal/emulador possui e execute

   $ stty rows 24 cols 80

3. Após o uso de alguma aplicação, os caracteres aparecem trocados ou o eco deixou de funcionar, ou quando pressiono enter o cursor permanece na mesma linha. Tentativa de solução:

   $ stty sane

4. Ao tentar executar uma aplicação, a mensagem de erro terminal capability cm required, ou Terminal type is not defined, ou Terminal type is not powerful enough, ou outra semelhante foi exibida. Solução: cheque o tipo de terminal que você está usando ou emulando (dificilmente será algo diferente de xterm ou vt100) e atribua para a variável de environment TERM esse valor.

Diretórios Principais do Sistema

No Unix não há o conceito de nomes de drives, como C:, mas todos os paths partem de uma raiz comum, o root directory “/”. Quando a máquina possui vários discos diferentes (ou ao menos várias partições diferentes de um mesmo disco), cada uma delas em geral corresponderá a uma subárvore do filesystem, como /usr, /var ou ainda nomes não standard como /disco2, que são chamados de seus pontos de montagem. O comando mount executado sem parâmetros listará os diferentes dispositivos físicos montados (discos locais e remotos e suas partições) e a subárvore correspondente a cada um deles. A tabela que indica todas essas montagens é o arquivo /etc/fstab. Apesar de algumas pequenas diferenças de plataforma para plataforma, os diretórios principais do sistema são:

O termo básico aplicado acima aos diretórios /bin e /lib quer significar principalmente essenciais para o boot e operação mínima do sistema. A separação desses elementos básicos, em contraposição aos que são deixados no /usr, deve-se a razões práticas, principalmente para facilitar a organização de redes de máquinas compartilhando subárvores de diretório. De fato, é comum que o diretório /usr ao invés de estar replicado em todas as máquina da rede esteja residindo fisicamente num único disco, e sendo compartilhado por todas as máquinas.

Atributos e Nomes de Arquivos

No Unix cada arquivo (inclusive diretórios, que são casos particulares de arquivos), conta com um conjunto de atributos de leitura, escrita e execução, que são setáveis através do comando chmod, e podem ser exibidos pelo comando ls -l:

$ ls -l /bin/cat
-rwxr-xr-x 1 root root 16584 Dec 16 20:09 /bin/cat

A string -rwxr-xr-x representa os atributos do arquivo /bin/cat. O primeiro caracter (-) significa que se trata de um arquivo regular, em contraposição aos diretórios (d), device special files (c) e links simbólicos (l). Os 9 caracteres restantes informam as permissões de leitura, escrita e execução desse arquivo relativas ao seu proprietário, ao seu grupo, e a todos os demais. O proprietário e o grupo são informados logo à direita, e no caso são o usuário root e o grupo root.

Note que no Unix não existem os atributos de arquivo oculto (“hidden”) e do sistema (“system”), suportados no MS-DOS. Não obstante, arquivos cujo primeiro caractere é ponto (“.”) normalmente são omitidos pelo ls, a não ser que se utilize a opção -a (de “all”), conforme comentamos no início.

Um atributo importantíssimo existente no Unix é o chamado setuid, através do qual um processo adquire ao ser executado os privilégios do owner do arquivo. Isso é frequentemente utilizado por programas que são disparados por usuários não privilegiados mas que por algum motivo necessitam dos privilégios do superusuário, por exemplo:

$ ls -l /usr/sbin/pppd
-rwsr-xr-x 1 root bin 104876 Apr 27 1998 /usr/sbin/pppd

Sem os privilégios de superusuário, um usuário comum não conseguiria configurar a interface ppp e nem alterar a tabela de rotas do sistema, no momento em que se conecta ao provedor Internet. Assim, o pppd, ao ser executado, requisitará os privilégios do owner do arquivo, que no caso é o superusuário, e dessa forma ele poderá realizar essas operações.

No Unix via de regra são suportados nomes “longos” (até 64 ou às vezes até 256 caracteres), e o “.” não é um separador entre o nome do arquivo e sua extensão, mas um caracter como os outros. Não obstante, a noção de “sufixo” é utilizada informalmente para facilitar a identificação de alguns formatos de arquivos, por exemplo:

Archives (o termo não tem correspondente em português) são concatenações de vários arquivos ou de subárvores inteiras num único arquivo. Em Unix, tipicamente são produzidos com tar:

$ tar cvf /tmp/etc.tar /etc
$ tar tvf /tmp/etc.tar /etc
$ cd  /tmp; tar xvf etc.tar

O primeiro comando irá criar o archive /tmp/etc.tar, composto por toda a subárvore /etc. O segundo exibirá o conteúdo desse archive. O terceiro irá extrair todo o seu conteúdo dentro do diretório /tmp, ou seja, recriará aquela mesma subárvore como uma subárvore do diretório /tmp.

Intercambiando Disquetes com o MS-DOS

Via de regra as plataformas Unix-like oferecem ferramentas para lidar com disquetes “formatados” no MS-DOS (ou, mais precisamente, disquetes que usam FAT). Um set de ferramentas bastante popular é o mtools, que oferece clones das ferramentas do MS-DOS. Exemplos de uso:

$ mformat a:
$ mcopy a:relat.txt .
$ mdir a:

Versões recentes dessas ferramentas lidam também com o VFAT do Windows 95, que permite nomes de arquivos “longos”.

O intercâmbio de arquivos texto entre Unix e MS-DOS deve ser feito com cuidado. Por herança das antigas impressoras, o fim-de-linha no MS_DOS é codificado através de dois caracteres (CR e LF), enquanto no Unix há apenas um (o LF), além do que o final do arquivo é sinalizado no MS-DOS por um CTRL-Z. O mcopy possui a opção -t para realizar essas conversões quando copia de ou para disquetes.

O Kernel

O Kernel do Unix (e de virtualmente qualquer outro sistema operacional) possui um papel de que convém ter noções, a fim de se poder compreender melhor o funcionamento do sistema, realizar diagnósticos e procedimentos administrativos como adição de componentes de hardware. Algum conhecimento do papel do kernel é importante também para se ter uma noção mais clara do uso de arquivos especiais e do diretório /proc.

O Kernel ordinariamente reside no filesystem como um outro arquivo qualquer. No Linux, ele é em geral o arquivo /vmlinuz ou /boot/vmlinuz, ou ainda /boot/vmlinuz-2.0.36. Ele é um programa, ainda que um pouco diferente dos programas de aplicação como o /bin/ls. O kernel é carregado e posto em execução no boot da máquina, e a sua execução somente se encerra com o shutdown.

De forma simplificada, o seu papel é num primeiro momento reconhecer o hardware e inicializar os respectivos drivers. Em seguida ele entra num estado administrativo onde funciona como intermediário entre as aplicações e o hardware. Por exemplo, quando uma aplicação necessita alocar mais memória, ela solicita isso ao kernel. É o kernel que distribui o tempo de CPU aos vários processos ativos. É ele que habitualmente realiza a entrada e saída de dados nas diferentes portas de comunicação.

É por isso que a adição de hardware novo a uma máquina pode requerer a substituição ou ao menos a reconfiguração do kernel. Os kernels mais recentes do Linux oferecem vários mecanismos de configuração que os tornam sobremaneira flexíveis, a ponto de ser rara a necessidade de substituição do kernel. Os dois mecanismos fundamentais de se configurar a operação do kernel são a passagem de parâmetros no momento do boot (realizada pelo LILO) e a carga de módulos, feita manualmente ou por mecanismos automáticos como o kerneld.

O diálogo entre as aplicações e o kernel realiza-se fundamentalmente através dos system calls, que são serviços que o kernel oferece, como por exemplo read(2). Os device special files são maneiras de se referir ao kernel os dispositivos físicos ou lógicos com que se pretende operar, por exemplo a primeira porta serial ou a segunda unidade de fita, ou o disco principal do sistema. Neles, o importante não é o nome, mas sim os números de dispositivo, ou mais precisamente o major e o minor device numbers. Device special files são criados através do comando mknod, ou através de interfaces mais amigáveis, como o comando MAKEDEV.

Os sistemas Unix-like mais recentes oferecem um outro mecanismo de comunicação com o kernel, que é o filesystem /proc. As entradas desse filesystem são pseudo-arquivos cujo conteúdo reflete o estado atual de inúmeras estruturas de dados internas do kernel. Assim, um programa de aplicação passa a poder comunicar-se com o kernel através dos mecanismos ordinários de leitura e escrita de arquivos.

Em muitos casos a comunicação entre as aplicações e o kernel é intermediada por bibliotecas, principalmente a libc. Elas oferecem serviços de mais alto nível que os system calls do kernel, tornando mais simples o trabalho de programação.

Redirecionamento da Entrada e da Saída; Pipes

Processos num sistema Unix habitualmente possuem três dispositivos de I/O “padrões”, a “saída padrão”, a “entrada padrão” e a “saída de erros”. O Unix permite que esses dispositivos (e outros) sejam definidos no momento da execução, podendo escolher o console, um “pipe”, a impressora, um circuito virtual de rede conectando duas máquinas, uma linha física serial ou outras coisas.

Usuários de MS-DOS talvez já tenham feito coisas como

C> DIR >PRN:

para imprimir a saída de um comando. Essa sintaxe foi herdada do Unix daí a semelhança:

$ ls -l >/dev/lp1

Naturalmente tanto no MS-DOS quanto no Unix existem formas mais apropriadas para se imprimir algo, mas no momento esse exemplo convém. Shells do estilo “Bourne” (sh, ksh, bash) permitem redirecionamento da saída de erros através da seguinte sintaxe:

$ rm /bin/ls 2>/tmp/error

O “2” deve-se a que, internamente, a saída de erros corresponde ao descritor 2 (o 0 é a entrada padrão e o 1 é a saída padrão).

A entrada pode ser redirecionada de forma semelhante:

$ wc </tmp/error 

Os shells Unix oferecem um recurso para a ligação da saída padrão de um processo com a entrada padrão de outro, chamado pipe:

$ ls|wc

No exemplo a saída do ls está sendo usada como entrada do wc. Note que o shell dispara os dois processos ao mesmo tempo. Se o primeiro estiver produzindo saída numa taxa superior à que o segundo lê, o sistema operacional paralizará o primeiro sempre que o buffer que armazena o tráfego estiver cheio. Isso significa, por exemplo, que um pipe pode ser usado mesmo quando o volume total da saída do primeiro processo é extraordinariamente grande, por exemplo quando se tenta localizar informações de arquivos deletados através de um dump de todos os setores do disco.

Comunicação Serial e Paralela

O Unix apresenta as portas de comunicação seriais e paralelas na forma de arquivos especiais. Já vimos um exemplo do seu uso no ítem Redirecionamento da Entrada e da Saída, em que fizemos a impressão da saída de um comando.

Na comunicação entre dois computadores, utiliza-se freqüentemente portas seriais, e às vezes também as paralelas. Em muitos casos, quando a distância entre os dois é grande, haverá uso de modems, e eventualmente também de uma linha telefônica. Através de três exemplos práticos pode-se ter um bom panorama do uso de comunicação serial no Unix. Como os procedimentos variam um pouco dependendo das plataformas em uso, só é possível indicá-los de forma genérica:

a) Adição de um terminal

1. Conectar a serial do terminal com a da máquina Unix.
2. Disparar no Unix a variante do getty disponível.
3. Logar no terminal.
4. Transferir arquivos se o terminal oferecer esse recurso.

b) Conexão a um sistema remoto

1. Disparar algum emulador de terminal disponível.
2. Selecionar a serial em que o modem está conectado.
3. Configurar o modo de operação da serial (velocidade, bits).
4. Configurar o modem através de comandos AT, se necessário.
5. Instruir o modem para discar, com ATD
6. Aguardar a negociação.
7. Logar.

c) Estabelecimento de um link ppp

1. Executar a conexão ao sistema remoto como indicada acima.
2. Iniciar o ppp no sistema remoto.
3. Disparar o pppd localmente.

Em PCs, os conectores externos das portas seriais são conectores DB-9 ou DB-25 macho, e os das paralelas são DB-25 fêmea.

Configuração do TCP/IP

Numa rede TCP/IP, a cada máquina está associado um número IP, que é um inteiro de 32 bits, normalmente escrito na forma de octetos, como 192.168.0.5. A cada máquina está associado um nome, como por exemplo marte ou pimenta.

A atribuição tanto do número quanto do nome é feita durante o processo de boot, a partir da especificação deles feita através da edição manual de arquivos de configuração e/ou do uso de aplicativos de gerenciamento do sistema específicos de cada plataforma.

Na verdade, o número IP não está associado à máquina, mas a uma determinada interface dela. Via de regra, a interface envolvida é a ethernet. Tanto para exibir quanto para setar manualmente o número IP de uma interface usa-se o comando ifconfig. Por exemplo, o comando:

$ ifconfig -a

irá listar todas as interfaces com informações de cada uma. A interface ethernet costuma chamar-se le0 (Solaris) ou eth0 (Linux). Além do ethernet, é comum usar-se portas seriais para criar interfaces TCP/IP, principalmente para criar links com linhas telefônicas. As placas ethernet costuma oferecer dois ou mais tipos de conectores. Ela pode ou não descobrir automaticamente qual está em uso. Em caso negativo, você deverá informá-la, o que habitualmente é feito através de um software de configuração que acompanha a placa.

O passo seguinte é a configuração das rotas. Através delas a máquina sabe por onde enviar datagramas a fim de que eles cheguem em seus destinos. Equivale de certa forma à sinalização do tráfego urbano, com placas indicativas da direção a tomar para atingir cada destino (Ponte do Limão à esquerda, ou Avenida Bandeirantes em frente, etc).

Cada rota envolve um destino, uma máscara, um gateway e uma interface. Pode-se exibir todas elas através do comando netstat:

$ netstat -r
Destination Gateway Genmask Iface
192.168.1.0 * 255.255.255.0 eth0
127.0.0.0 * 255.0.0.0 lo
default 192.168.1.1 0.0.0.0 eth0

Suponha que você deseja atingir a máquina 192.168.1.7. A aplicação da tabela de rotas indica, através de uma operação e bit-a-bit entre 192.168.1.7 e a máscara 255.255.255.0, que deve ser usada a primeira rota. Como não há gateway, a comunicação será feita diretamente através do ethernet.

Se o destino agora for 200.136.35.65, as duas primeiras rotas não nos servirão (experimente aplicar o e como no caso anterior). Portanto será usada a rota default, e como ela especifica um gateway, a comunicação terá que ser feita através dele. Assim, toda vez que se pretender enviar alguma informação para o 200.136.35.65, esta será enviada antes para o gateway 192.168.1.1, na esperança de que este consiga roteá-la para o seu destino.

Serviços TCP/IP

Atualmente é comum as pessoas confundirem Internet com a teia mundial WWW, entretanto muito antes de surgir a teia, a Internet já usava um sem-número de serviços construídos a partir dos protocolos de transporte TCP e UDP.

Um circuito TCP entre duas máquinas equivale a um pipe duplo entre dois processos, cada um rodando em uma das máquinas. O telnet é um típico serviço que se utiliza desse recurso, a fim de criar sessões remotas. Pode-se exibir todas os circuitos TCP ativos através do comando netstat:

$ netstat -t

O FTP, por sua vez, cria dois circuitos, utilizando um para envio de comandos e outro de dados. Através do uso de alguns comandos simples, permite transferir arquivos de ou para uma máquina remota. Os principais comandos do FTP são:

Disparo do Xwindows e das suas aplicações

O disparo do X é desnecessário quando o sistema opera num runmode em que o X está permanentemente ativo. Nesse caso, o próprio login é feito numa janela, ao invés de no console no modo texto.

Quando for necessário disparar o X manualmente, via de regra haverá dois ou três scripts já preparados para isso, como o startx ou o openwin. O que eles fazem basicamente é definir uma série de parâmetros e executar o xinit, que por sua vez dispara o Xserver e o Window Manager.

Convém não perder de vista que o Xwindows é um sistema cliente-servidor. O Xserver é o programa que conhece o hardware gráfico, é capaz de colocar o display no modo desejado, e desenhar nele. As aplicações conectam o Xserver através de um circuito TCP (por exemplo) e enviam a ele comandos através dos quais desenham as suas janelas e o conteúdo delas. O Window Manager é responsável por desenhar as molduras das janelas, criar menus de aplicações, e controlar o foco.

Assim, é natural que no disparo de cada aplicação seja necessário especificar qual é o server a ser utilizado. Isso normalmente se faz através da opção de linha de comando -display, ou através da variável de environment DISPLAY.

$ xterm -display 192.168.0.1:0.0
$ DISPLAY=192.168.0.1:0.0; export DISPLAY; xterm

Quando o Xserver está rodando numa máquina Unix, a permissão para um cliente usá-lo é dada através do comando xhost:

$ xhost +192.168.1.5 (autoriza o cliente 192.168.1.5)
$ xhost -192.168.1.5 (desautoriza o cliente 192.168.1.5)
$ xhost (lista os clientes autorizados)

Pode-se autorizar permanentemente um cliente a usar um determinado Xserver adicionando-o ao arquivo /etc/X0.hosts (um cliente por linha).

Ao longo dos anos foram sendo criados inúmeros Window Managers diferentes para o Xwindows. Algumas vezes além do window manager foram criadas também complexas bibliotecas oferecendo serviços de alto nível que além de simplificar o trabalho de programação tamém permitem estandardizar o aspecto visual e os recursos das janelas das aplicações. Um dos produtos mais conhecidos dessa linha é o Motif. O advento do Free Software criou outras opções, sendo as mais em voga atualmente o GTK e o QT, que são utilizados respectivamente pelo GNOME e pelo KDE.

Procedimentos de boot e o init

O boot do Unix consiste inicialmente na carga e execução do kernel. Em seguida, é disparado o processo init, que segue as instruções do arquivo /etc/inittab, que portanto é o ponto de partida para tudo o que se pretenda configurar a nível de disparo de processos ao longo do boot.

O inittab não é um script como o AUTOEXEC.BAT, mas uma lista de ações, algumas delas de valor permanente para todo o curso da operação do sistema. Cada linha válida representa um processo que o init deve disparar. O termo respawn significa que, além de disparar, o init deverá monitorar o processo e, se porventura ao longo da operação do sistema ele for encerrado, o init deverá redispará-lo.

Via de regra as linhas do inittab referem-se ou à chamada de scripts de configuração inicial do sistema, que são executados apenas uma vez, ou aos processos de controle de login no sistema, que são redisparados sempre que ocorre um logout. O inittab inclui ainda o conceito de runlevel, o que cria a flexibilidade de se poder inicializar a máquina em um de vários possíveis modos de operação. Na prática, costuma haver três modos principais, o single-user, utilizado para manutenção, um gráfico e um não gráfico.

Quanto aos scripts de configuração (normalmente são os arquivos e/ou diretórios /etc/rc.*, dependendo da plataforma a mecânica de disparo deles pode ser bastante complexa. Note que cada runlevel pode disparar ou deixar de disparar alguns scripts, a fim de estabelecer o modo de operação desejado. Em quase todas as versões mais recentes do Linux essa mecânica segue o padrão dos diretórios /etc/rc.d/rcN.d, onde N é cada um dos runlevels. O conteúdo desses diretórios são links para cada um dos scripts de ativação ou desativação de serviços básicos (interfaces de rede, servidor de email, etc), com números embutidos nos nomes dos links, a fim de definir a ordem em que devem ser processados.

Referências

Virtualmente qualquer informação técnica sobre sistemas Unix-like pode ser obtida na Teia Mundial. Estou colocando aqui apenas um referência clássica (o Livro do Bach), e um link para uma lista de pontos de entrada de documentação sobre Linux.

[1] Bach, M. J. The Design of the Unix Operating System, Prentice-Hall, 1986.

[2] Alguns links de Linux, inclusive para materiais em português, estão disponíveis em http://www.ime.usp.br/~ueda/ldoc/links.html .

Fonte: http://www.ufrgs.br

Related posts:

1. Estilizando o PROMPT da console (com uso de cores) Para quem gosta de trabalhar com a console (modo texto)...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

uso, módulos comumente usados.

ATENÇÃO:
Esta aula faz parte do curso Perl Tutorial e é continuacao do curso Perl
Intro, também disponibilizado no LinuxChix.org.br. Esta aula de forma alguma
cobre todas as informações disponíveis sobre Perl best practices ou Perl
modules.

*** Transformando um código mal formatado/identado em um código mais
legível.

Formatar o código de maneira legível é parte das “boas praticas”
recomendadas para programadores em qualquer linguagem de programação. O fato
é que cada programador tem uma preferência diferente na hora de formatar um
código, o que pode dificultar (e porque não dizer, irritar) a vida de quem
precisa ler/alterar o código que outra pessoa escreveu.

Por exemplo, vejá o mesmo programa formatado de maneiras diferentes:

# FORMATACAO 1:

my $código= “XYZ456475″;
my $data = “2006/04/23″ ;

my $resposta_do_teste =testar_formato_dos_dados ($código,$data );

print “$resposta_do_teste\n” ;

sub testar_formato_dos_dados
{
my($código,$data)=@_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}}
and $código =~ m{[A-Z]{3}\d+}){
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
}
else{ return “Os dados não estao no formato correto” ;
}
}

# FORMATACAO 2:

my $código = “XYZ456475″;
my $data = “2006/04/23″;
my $resposta_do_teste = testar_formato_dos_dados($código, $data);
print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($código, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $código =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados não estao no formato correto”;
}
}

# FORMATACAO 3:

my $código = “XYZ456475″;
my $data = “2006/04/23″;

my $resposta_do_teste = testar_formato_dos_dados($código, $data);

print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($código, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $código =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados não estao no formato correto”;
}
}

— Alguns programadores, por exemplo, poderiam achar horrivel de ler um
código usando a FORMATACAO 1 porque esse exemplo não segue um estilo na
formatação.

Num mundo ideal, os programadores de um determinado projeto e/ou equipe
teriam padrões de programacao a serem seguidos. No mundo real – onde a
teoria é por muitas vezes diferente da prática – existe o Perltidy para
facilitar a vida dos Perl programmers:

http://search.cpan.org/~shancock/Perl-Tidy-20060719/bin/perltidy

— PELRTIDY: uma ferramenta muito util para identar e reformatar um código.
Ele lê um script em Perl e reformata/identa o script. Um exemplo bem simples
de uso:

$ perltidy o_seu_script.pl

- Nesse caso, o perltidy lê o conteúdo do o_seu_script.pl e cria um arquivo
chamado o_seu_script.pl.tdy que contém o código original reformatado. O
conteúdo do arquivo o_seu_script.pl permanece inalterado.

Há inumeras opcoes que podem ser passadas para o perltidy para que ele
funcione de acordo com a sua preferencia. Alguns outros exemplos são:

$ pertidy -b o_seu_script.pl

- Nesse caso, o perltidy altera o arquivo o_seu_script.pl e faz um backup do
conteúdo original em o_seu_script.pl.bak.

$ perltidy -gnu o_seu_script.pl

- Nesse caso, o o_seu_script.pl é reformatado num estilo aproximado ao do
GNU Coding Standards para programas em C.

# MAIS informações
Mais informações sobre o perltidy podem se encontradas no CPAN.org (link
citado acima) e nos seguintes links:

http://perltidy.sourceforge.net/stylekey.html

http://perltidy.sourceforge.net/tutorial.html

*** Perl modules: instalações, uso, módulos comumente usados.

### O QUE é?
Falando de uma forma bem simples, um módulo pode ser definido como um
arquivo que contem uma ou mais funcoes. Um módulo pode ou não ser orientado
a objeto – mas antes de falar sobre orientacao a objeto é necessario que se
tenha um bom entendimento sobre módulos. O assunto orientacao a objeto será
abordado laaaaa nas próximas aulas.

OBS.: Se voce não se lembra o que é ou como criar/usar funcoes em Perl, de
uma olhada na aula 4 do curso de introducao ao Perl. E, se continuar em
duvida, mande uma mensagem para o grupo.

### PARA QUE SERVE?
módulos são usados como uma forma de reaproveitamento de código. Assim, se
voce tem várioss programas que utilizam o mesmo conjunto de funcoes, voce
pode colocar esse conjunto de funcoes dentro de um módulo e fazer com que os
seus programas usem esse módulo.

OBS.: O assunto “criando módulos em Perl” será abordado laaaa nas próximas
aulas. Muita calma nessa hora. Por enquanto so será abordado como instalar e
usar módulos que já estao prontos e disponiveis.

Diversos programadores disponibilizam os seus módulos através do CPAN.org.
Alguns módulos já são disponibilizados na propria distribuição do Perl.
várioss outros podem ser baixados no site CPAN.org.

Sendo assim, evite reinventar a roda. Se já existe um módulo que faz o que
voce precisa, não hesite, utilize-o-o-o. Por exemplo, se voce precisa de um
módulo que envie email, antes de escrever o seu código, acesse o
search.cpan.org e procure por mail. Há grandes chances de que já exista um
módulo que faz exatamente o que voce quer, disponível, bem documentado e
testado. não tenha medo de usa-lo.

E ha os tipos de módulos que servem para alterar a forma como o Perl
funciona.

### COMO USAR?
Depende do módulo. Cada módulo vem com uma documentacao explicando suas
funcionalidades e exemplos de como usa-las.

A documentacao pode ser acessada digitando na linha de comando:

$ perldoc NOME_DO_módulo

Por exemplo:

$ perldoc Net::FTP

De forma geral, antes de usar qualquer funcao de um módulo é necessario
declara-lo. Isto é, é necessario “avisar” o seu programa que ele utiliza
funcoes que não estao localizadas dentro do proprio programa, mas sim dentro
de um outro arquivo. Assim como tudo em Perl, ha mais de uma forma de se
fazer isso. Uma delas é usar o operador “use”.

OBS: Se voce não se lembra do operador use, de uma olhada na primeira aula
do curso de Introducao ao Perl. Desde o comeco do curso a orientacao era
para que todos os programas criados comecassem com as linhas citadas abaixo.
Naquela aula eu não dei muitos detalhes do porque e falei que o assunto
seria abordado nas aulas seguintes. A hora chegou.

use strict;
use warnings;

Essas linhas servem para carregar os módulos strict e warnings do Perl.
Ambos são módulos que servem para alterar a forma como o Perl funciona.

O módulo strict obriga a declaracao do escopo das variaveis. Sim, o seu
código vai funcionar mesmo que essa linha sejá omitida. Mas o uso do módulo
strict faz parte do Perl best practices. Usar o strict faz com que o seu
código sejá menos sujeito a erros.

O módulo warnings ativa a emissão de… warnings. Permite que o Perl emita
warnings quando o código tem um erro, mesmo que esse erro não sejá fatal.

Por exemplo:

use strict;
use warnings;

my $numero = 10;
$numero += ‘t’;
print $numero . “\n”;

Esse código contem um erro, mas como esse erro não é fatal, o Perl vai
rodar normalmente. Porem esse código não vai conseguir fazer a conta ” t +
10 ” e vai emitir um warning.

### COMO INSTALAR?

Primeiro verifique se o módulo já não esta instalado na sua maquina. De
novo, ha mais de uma forma de se fazer isso, uma delas é rodar na linha de
comando:

$ perl -MNome_do_módulo -e 1

Por exemplo, se voce não tem certeza se os módulos Net::FTP ou DBD::Oracle
já estao instalados, rode na linha de comando:

$ perl -MNet::FTP -e 1
$ perl -MDBD::Oracle -e 1

Se o módulo não estiver instalado, uma mensagem de erro será mostrada. Se
não aparecer nenhum erro, significa que o módulo já esta instalado.

Ola, todo mundo.

Esta aberta a segunda temporada do curso de Perl: Perl Tutorial.
Nessa fase do curso, serao abordados os assuntos referencias, modulos,
orientacao a objeto, best practices, perl style, entre outros.

A primeira temporada – Perl Intro – esta nos arquivos da lista e podem ser
acessados nos seguintes links:

Aula 1:

http://listas.linuxchix.org.br/pipermail/cursos/2006-March/000002.html

Aula 2:

http://listas.linuxchix.org.br/pipermail/cursos/2006-April/000004.html

Aula 3:

http://listas.linuxchix.org.br/pipermail/cursos/2006-April/000039.html

Aula 4: http://listas.linuxchix.org.br/pipermail/cursos/2006-May/000048.html
Aula 5: http://listas.linuxchix.org.br/pipermail/cursos/2006-May/000050.html

Uma breve apresentacao, para quem nao me conhece: meu nome eh Lucia e eu
moro em Toronto, no Canada. Eu sou Analista de Sistemas e trabalho como
consultora em analise e desenvolvimento de sistemas para empresas de
telecomunicacoes tanto aqui do Canada como dos Estados Unidos.

Para quem ainda nao eh familiar com a apresentacao do curso: as aulas sao
enviadas aproximadamente 1 vez por semana. Quaisquer duvidas a respeito das
aulas devem ser enviadas para o grupo, atraves do e-mail
cursos em linuxchix.org.br.

Qualquer assunto relacionado a programacao, mas nao relacionado ao curso
atualmente ministrado, deve ser enviado para o programacao em linuxchix.org.br.

Eh isso. Fim do bla bla bla.
A primeira aula dessa segunda parte do curso vira na proximo email.

Cheers!
Lucia
————– Próxima Parte ———-
Um anexo em HTML foi limpo…
URL: http://listas.linuxchix.org.br/pipermail/cursos/attachments/20070205/bb6576b8/attachment.html

## Perl Tutorial – Parte 1 ###

Perl best practices: escrevendo codigos legiveis; Perl modules: instalacao,
uso, modulos comumente usados.

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula de forma alguma
cobre todas as informacoes disponiveis sobre Perl best practices ou Perl
modules.

*** Transformando um codigo mal formatado/identado em um codigo mais
legivel.

Formatar o codigo de maneira legivel eh parte das “boas praticas”
recomendadas para programadores em qualquer linguagem de programacao. O fato
eh que cada programador tem uma preferencia diferente na hora de formatar um
codigo, o que pode dificultar (e porque nao dizer, irritar) a vida de quem
precisa ler/alterar o codigo que outra pessoa escreveu.

Por exemplo, veja o mesmo programa formatado de maneiras diferentes:

# FORMATACAO 1:

my $codigo= “XYZ456475″;
my $data = “2006/04/23″ ;

my $resposta_do_teste =testar_formato_dos_dados ($codigo,$data );

print “$resposta_do_teste\n” ;

sub testar_formato_dos_dados
{
my($codigo,$data)=@_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}}
and $codigo =~ m{[A-Z]{3}\d+}){
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
}
else{ return “Os dados NAO estao no formato correto” ;
}
}

# FORMATACAO 2:

my $codigo = “XYZ456475″;
my $data = “2006/04/23″;
my $resposta_do_teste = testar_formato_dos_dados($codigo, $data);
print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($codigo, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $codigo =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados NAO estao no formato correto”;
}
}

# FORMATACAO 3:

my $codigo = “XYZ456475″;
my $data = “2006/04/23″;

my $resposta_do_teste = testar_formato_dos_dados($codigo, $data);

print “$resposta_do_teste\n”;

sub testar_formato_dos_dados {
my ($codigo, $data) = @_;

if ( $data =~ m{\d{4}/\d{2}/\d{2}} and $codigo =~ m{[A-Z]{3}\d+} ) {
print “qualquer texto \n”;
return “Os dados estao no formato correto”;
} else {
return “Os dados NAO estao no formato correto”;
}
}

— Alguns programadores, por exemplo, poderiam achar horrivel de ler um
codigo usando a FORMATACAO 1 porque esse exemplo nao segue um estilo na
formatacao.

Num mundo ideal, os programadores de um determinado projeto e/ou equipe
teriam padroes de programacao a serem seguidos. No mundo real – onde a
teoria eh por muitas vezes diferente da pratica – existe o Perltidy para
facilitar a vida dos Perl programmers:

http://search.cpan.org/~shancock/Perl-Tidy-20060719/bin/perltidy

— PELRTIDY: uma ferramenta muito util para identar e reformatar um codigo.
Ele le um script em Perl e reformata/identa o script. Um exemplo bem simples
de uso:

$ perltidy o_seu_script.pl

- Nesse caso, o perltidy le o conteudo do o_seu_script.pl e cria um arquivo
chamado o_seu_script.pl.tdy que contem o codigo original reformatado. O
conteudo do arquivo o_seu_script.pl permanece inalterado.

Ha inumeras opcoes que podem ser passadas para o perltidy para que ele
funcione de acordo com a sua preferencia. Alguns outros exemplos sao:

$ pertidy -b o_seu_script.pl

- Nesse caso, o perltidy altera o arquivo o_seu_script.pl e faz um backup do
conteudo original em o_seu_script.pl.bak.

$ perltidy -gnu o_seu_script.pl

- Nesse caso, o o_seu_script.pl eh reformatado num estilo aproximado ao do
GNU Coding Standards para programas em C.

# MAIS INFORMACOES
Mais informacoes sobre o perltidy podem se encontradas no CPAN.org (link
citado acima) e nos seguintes links:

http://perltidy.sourceforge.net/stylekey.html

http://perltidy.sourceforge.net/tutorial.html

*** Perl modules: instalacao, uso, modulos comumente usados.

### O QUE EH?
Falando de uma forma bem simples, um modulo pode ser definido como um
arquivo que contem uma ou mais funcoes. Um modulo pode ou nao ser orientado
a objeto – mas antes de falar sobre orientacao a objeto eh necessario que se
tenha um bom entendimento sobre modulos. O assunto orientacao a objeto sera
abordado laaaaa nas proximas aulas.

OBS.: Se voce nao se lembra o que eh ou como criar/usar funcoes em Perl, de
uma olhada na aula 4 do curso de introducao ao Perl. E, se continuar em
duvida, mande uma mensagem para o grupo.

### PARA QUE SERVE?
Modulos sao usados como uma forma de reaproveitamento de codigo. Assim, se
voce tem varios programas que utilizam o mesmo conjunto de funcoes, voce
pode colocar esse conjunto de funcoes dentro de um modulo e fazer com que os
seus programas usem esse modulo.

OBS.: O assunto “criando modulos em Perl” sera abordado laaaa nas proximas
aulas. Muita calma nessa hora. Por enquanto so sera abordado como instalar e
usar modulos que ja estao prontos e disponiveis.

Diversos programadores disponibilizam os seus modulos atraves do CPAN.org.
Alguns modulos ja sao disponibilizados na propria distribuicao do Perl.
Varios outros podem ser baixados no site CPAN.org.

Sendo assim, evite reinventar a roda. Se ja existe um modulo que faz o que
voce precisa, nao hesite, utilize-o-o-o. Por exemplo, se voce precisa de um
modulo que envie email, antes de escrever o seu codigo, acesse o
search.cpan.org e procure por mail. Ha grandes chances de que ja exista um
modulo que faz exatamente o que voce quer, disponivel, bem documentado e
testado. Nao tenha medo de usa-lo.

E ha os tipos de modulos que servem para alterar a forma como o Perl
funciona.

### COMO USAR?
Depende do modulo. Cada modulo vem com uma documentacao explicando suas
funcionalidades e exemplos de como usa-las.

A documentacao pode ser acessada digitando na linha de comando:

$ perldoc NOME_DO_MODULO

Por exemplo:

$ perldoc Net::FTP

De forma geral, antes de usar qualquer funcao de um modulo eh necessario
declara-lo. Isto eh, eh necessario “avisar” o seu programa que ele utiliza
funcoes que nao estao localizadas dentro do proprio programa, mas sim dentro
de um outro arquivo. Assim como tudo em Perl, ha mais de uma forma de se
fazer isso. Uma delas eh usar o operador “use”.

OBS: Se voce nao se lembra do operador use, de uma olhada na primeira aula
do curso de Introducao ao Perl. Desde o comeco do curso a orientacao era
para que todos os programas criados comecassem com as linhas citadas abaixo.
Naquela aula eu nao dei muitos detalhes do porque e falei que o assunto
seria abordado nas aulas seguintes. A hora chegou.

use strict;
use warnings;

Essas linhas servem para carregar os modulos strict e warnings do Perl.
Ambos sao modulos que servem para alterar a forma como o Perl funciona.

O modulo strict obriga a declaracao do escopo das variaveis. Sim, o seu
codigo vai funcionar mesmo que essa linha seja omitida. Mas o uso do modulo
strict faz parte do Perl best practices. Usar o strict faz com que o seu
codigo seja menos sujeito a erros.

O modulo warnings ativa a emissao de… warnings. Permite que o Perl emita
warnings quando o codigo tem um erro, mesmo que esse erro nao seja fatal.

Por exemplo:

use strict;
use warnings;

my $numero = 10;
$numero += ‘t’;
print $numero . “\n”;

Esse codigo contem um erro, mas como esse erro nao eh fatal, o Perl vai
rodar normalmente. Porem esse codigo nao vai conseguir fazer a conta ” t +
10 ” e vai emitir um warning.

### COMO INSTALAR?

Primeiro verifique se o modulo ja nao esta instalado na sua maquina. De
novo, ha mais de uma forma de se fazer isso, uma delas eh rodar na linha de
comando:

$ perl -MNome_do_modulo -e 1

Por exemplo, se voce nao tem certeza se os modulos Net::FTP ou DBD::Oracle
ja estao instalados, rode na linha de comando:

$ perl -MNet::FTP -e 1
$ perl -MDBD::Oracle -e 1

Se o modulo nao estiver instalado, uma mensagem de erro sera mostrada. Se
nao aparecer nenhum erro, significa que o modulo ja esta instalado.

Para os casos que voce precisa de um modulo que nao esta instalado na
maquina, acesse o site do CPAN e faca o download do modulo. Cada modulo tem
instrucoes especificas de instalacao. De um modo geral, sera algo como:

tar xfvz module.tar.gz
cd module
perl Makefile.PL
make
make test
make install

ATENCAO: As instrucoes acima sao apenas um exemplo e nao substituem a
leitura do arquivo README (com instrucoes especificas para a instalacao) que
vem junto com cada modulo.

# MAIS INFORMACOES:

Para acessar a documentacao de um modulo, digite na linha de comando:

$ perldoc NOME_DO_MODULO

Por exemplo:

$ perldoc strict

$ perldoc Net::FTP

*** Exercicios

a) Reveja os codigos desenvolvidos na primeira fase do curso e analise a
formatacao usada.

b) Dos 3 exemplos de formatacao dados acima, qual voce acha mais dificil e
qual voce acha mais facil de ler. Porque.

c) Instale o perltidy. Procure codigos perl (no historico do curso, no
google, etc) e rode perltidy neles experimentado as varias opcoes do
perltidy que estao disponiveis. Descubra qual a melhor configuracao do
perltidy para voce.

d) Verifique se a sua maquina tem um modulo chamado CPAN. Se nao tiver,
acesse o search.cpan.org, procure por esse modulo e instale-o. Acesse a
documentacao do modulo (que estara disponivel na sua maquina uma vez o
modulo esteja instalado) e entenda para que ele serve.

#PROXIMAS AULAS:
Perl functions
Validando/testando codigos
Uso de referencias em Perl
Perl style
————– next part ————–
An HTML attachment was scrubbed…
URL: http://listas.linuxchix.org.br/pipermail/cursos/attachments/20070205/49e7b8d0/attachment.html
## Perl Tutorial – Parte 2 ###

Perl functions: Algumas das builtin functions do Perl explicadas atraves de
exemplos

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as Perl functions, para obter uma lista completa das mesmas, acesse a
documentacao do Perl.

*** Lembretes

— 1. Documentacao especifica:

- Digite na linha de comando:

$ man perlfunc

- ou para acessar direto o man de uma determinada funcao:

$ perldoc -f nome_da_funcao

— 2. Executando os exemplos dados:

- SEMPRE comece os seus programas com as seguintes linhas:

#!/usr/bin/perl
use strict;
use warnings;

- Copie e cole os trechos de programas de exemplo logo abaixo dessas 3
linhas e salve o arquivo.
- Execute o programa na linha de comando.

— 3. Tirando duvidas

- consulte as aulas anteriores
- envie email para a lista

*** Funcoes para tratamento de strings

— Funcoes: uc, lc, lcfirst e ucfirst

- Exemplo de uso:

my $string = ‘TeM GeNtE QuE EsCrEvE AsSiM.’;
print uc $string .”\n”;
print lc $string .”\n”;

- Resultado ao executar o exemplo acima:

TEM GENTE QUE ESCREVE ASSIM.
tem gente que escreve assim.

- Notas:

uc – retorna a versao em letras maiusculas (uppercase) de uma string
lc – retorna a versao em letras minusculas (lowercase) de uma string
Use a funcao lcfirst para transformar em minuscula apenas a primeira letra
da string
Use a funcao ucfirst para transformar em maiuscula apenas a primeira letra
da string

— Funcao: length

- Exemplo de uso:

my $string = ‘inconstitucionalissimamente’;
print length($string) . “\n”;

- a funcao length retorna o tamanho em caracteres de uma string

- Exercicio:
Execute o exemplo acima; edite o programa e retire os parenteses em torno da
variavel $string e execute o programa novamente; compare os resultados e
entenda o porque de os parenteses serem necessarios nesse caso.

*** Funcoes para tratamento de listas

— Funcao: shift

- Exemplo de uso:

my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);
print “@os\n”;
shift @os;
print “@os\n\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
CentOS Windows HP-UX AIX Solaris

- Notas:

shift – remove e retorna o primeiro elemento de um array

# Na aula 4 do PerlIntro ha outros exemplos do uso do shift.

— Funcao: push

- Exemplo de uso:

my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);
print “@os\n”;
push (@os, “Ubuntu”);
print “@os\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
Fedora CentOS Windows HP-UX AIX Solaris Ubuntu

- Notas:

push – usado para acrescentar um ou mais elementos ao final de um array

— Funcao: qw

- Exemplo de uso:

my @os = qw(Fedora CentOS Windows HP-UX AIX Solaris);
print “@os\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris

- Notas:

o qw() – faz com que cada elemento dentro do “()” separado por um espaco
seja um elemento de um array

Usar:
my @os = qw/Fedora CentOS Windows HP-UX AIX Solaris/;

eh a mesma coisa que usar:
my @os = (“Fedora”, “CentOS”, “Windows”, “HP-UX”, “AIX”, “Solaris”);

Note que o qw separa um elemento do outro baseado em espacos, entao o qw nao
funciona para elementos compostos por duas ou mais palavras, como por
exemplo:

my @os = (“Fedora Core”, “Sun Solaris”); # indica um array de 2 elementos.

my @os = qw/Fedora Core Sun Solaris/; # indica um array de 4 elementos.

— Funcao: reverse

- Exemplo de uso:

my @os = qw/Fedora CentOS Windows HP-UX AIX Solaris/;
print “@os\n”;
my @os_invertido = reverse @os;
print “Array invertido: @os_invertido\n”;

- Resultado ao executar o exemplo acima:

Fedora CentOS Windows HP-UX AIX Solaris
Array invertido: Solaris AIX HP-UX Windows CentOS Fedora

- Notas:

reverse – num contexto de lista, retorna a lista com os elmentos em ordem
inversa

- Exercicios:

1. Crie um programa parecido com o exemplo acima, mas usando a funcao
reverse num contexto de string, nao de lista. Compare os resultados e
entenda a diferenca de comportamento da funcao reverse quando usada no
contexto de scalar e contexto de lista.

2. Execute o exemplo acima, trocando a funcao reverse pela funcao sort.
Descubra para que serve a funcao sort.

*** Funcoes para tratamento de listas/strings

— Funcao: join

- Exemplo de uso:

my @os_array = qw/usuario senha email homepage/;
my $os_string = join(‘:’, @os_array);
print “$os_string\n\n”;

- Resultado ao executar o exemplo acima:

usuario:senha:email:homepage

— Funcao: split

- Exemplo de uso:

my $string = ‘usuario:::senha:::email:::homepage’;
my ($usuario, $senha, $email, $homepage) = split(/:::/, $string);

print “User: $usuario\n”;
print “Passwd: $senha\n”;
print “E-mail: $email\n”;
print “Home Page: $homepage\n\n”;

- Resultado ao executar o exemplo acima:

User: usuario
Passwd: senha
E-mail: email
Home Page: homepage

- Notas:

join – agrupa os elementos de uma lista em uma string, separados pelo
pattern passado como parametro.
split – quebra/separa uma string, usando como separador o pattern passado
como parametro

O join espera como parametros um delimitador e uma lista. No caso do exemplo
acima, o delimitador usado eh o “:” (dois pontos). Uma serie de outros
delimitadores podem ser usados tambem.

*** Funcoes para tratamento de diretorios:

— Funcoes: opendir, closedir, readdir

- Exemplo de uso

my $dir = ‘/etc’;
my $dir_handle;

opendir ($dir_handle, “<”, $dir) || die “Erro ao abrir diretorio $dir: $!”;

foreach my $file ( readdir($dir_handle) ) {
print “$file \n\n”;
}

closedir ($dir_handle);

- Resultado ao executar o exemplo acima:

Uma lista dos arquivos que estao no /etc do seu computador.

- Notas:

opendir – abre um diretorio para processamento
closedir – fecha um diretorio
readdir – retorna o conteudo do diretorio

*** Funcoes para controle de loops

— Funcoes: next, last

- Exemplo de uso

my $dir = ‘/etc’;
my $dir_handle;

opendir ($dir_handle, $dir) || die “Erro ao abrir diretorio $dir: $!”;

foreach my $file ( readdir($dir_handle) ) {
next if ($file =~ /^\./);
print “$file \n\n”;
}

closedir ($dir_handle);

- Resultado ao executar o exemplo acima:

Uma lista dos arquivos que estao no /etc do seu computador. Porem, os hidden
files (os que comecam com ‘.’) nao serao printed por causa dessa linha de
codigo que eh ate bem auto explicativa:

next if ($file =~ /^\./);

Se um arquivo comeca com “.”, a funcao next eh chamada. E essa funcao faz
com que as linhas de codigo a seguir ate o fim do loop ao qual a funcao
pertence sejam ignoradas e comeca a proxima iteracao do loop.

- Notas:

A funcao last eh usada no mesmo contexto que a funcao next, porem a funcao
last forca uma saida do loop em definitivo. Um exmplo de uso:

last if ($file =~ /^a/);

nesse caso, assim que o loop encontrar um arquivo que comeca com a letra a,
a saida do loop sera forcada.

O comando next eh similar ao continue da linguagem C e o comando last eh
similar ao break do C.

*** Aplicacao pratica de algumas das funcoes citadas

— Programa que le o arquivo /etc/passwd, e imprime os nomes dos usuarios
em ordem alfabetica. Usuarios cujo ID seja igual ou menor que 15 sao
ignorados.

- Um exemplo de como implementar:

my $file = ‘/etc/passwd’;
my $fh;
my @users;

# abre arquivo /etc/passwd
open( $fh, “<”, $file ) || die “Erro ao abrir arquivo $file: $!”;

while (<$fh>) {
my %user;

# le cada linha do arquivo
# separa o conteudo usando : como delimitador
# guarda o resultado em um hash
@user{qw( login passwd uid gid gcos home shell )} = split( /:/, $_ );

# ignora alguns usuarios baseado num criterio
next if ( $user{uid} <= 15 );

# guarda os usuarios em um array
push( @users, $user{login} );
}

# separa o conteudo do array por um \n
# ordena o array
print join(“\n”, sort @users);

close($fh);

*** Exercicios

a) Execute os codigos de exemplo desta aula.

b) Crie um programa que le os arquivos /etc/passwd e /etc/group e imprime o
nome do usuario seguido do nome do grupo ao qual ele pertence.

- Informacoes adicionais:

Para quem nao conhece, o formato do arquivo /etc/passwd eh, por exemplo:

root:x:0:0:root:/root:/bin/bash

As informacoes: login, senha, id do usuario, id do grupo, info sobre o
usuario, home directory, shell sao separadas por “:”.

O formato do /etc/group eh, por exemplo:
root:x:0:root

ou

vfat:x:333:fulana,beltrana

As informacoes: nome do grupo, senha, id do grupo, lista de usuarios que
pertencem ao grupo sao separadas por “:”.

Para mais informacoes sobre o /etc/passwd ou /etc/group, acesse o manual,
por exemplo, digitando na linha de comando:

$ man 5 passwd
$ man group

## Perl Tutorial – Parte 3 ###

Data Structure: references, debugging

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as informacoes disponiveis sobre estrutura de dados, referencias e code
debugging em Perl; para obter informacoes completas, acesse a documentacao
do Perl.

*** Documentacao especifica:

- Digite na linha de comando:

$ man perlreftut
$ man perldsc

*** Perl references

— O que eh:
Eh uma importante feature do Perl que possibilita o uso de estruturas de
dados mais complexas do que simples arrays ou hashes.
Eh similar a ponteiros na linguagem C.

— Para o que serve:
Entre outras coisas, serve para lidar com estruturas de dados mais
complexas.

Fato eh que um array em Perl so pode conter valores do tipo scalar; o mesmo
vale para os valores das keys de um hash. As referencias sao um tipo de
workaround para esse fato.

Vejamos a lista abaixo, de paises e cidades, como exemplo de como o uso de
referencias torna mais facil a organizacao da mesma em um programa.

Brasil: Sao Paulo
Argentina: Buenos Aires
Brasil: Rio de Janeiro
Canada: Toronto
USA: Boston
Canada: Ottawa
Canada: Montreal
USA: New York
Canada: Windsor

Se voce estava pensando em algo como:

#CODIGO1:

my %paises = (
“Brasil” => “Sao Paulo”, “Rio de Janeiro”,
“Canada” => “Toronto”, “Ottawa”, “Montreal”, “Windsor”,
# etc
);

Think again!

O trecho de codigo acima nao e’ valido, pois ele esta “armazenando” uma
lista em cada key do hash paises, e isso nao eh possivel em Perl.

Uma forma correta de lidar com a estrutura acima, armazenando mais de um
valor em cada key do hash eh atraves do uso de referencias:

#CODIGO2:

my %paises = (
“Brasil” => [ "Sao Paulo", "Rio de Janeiro", ],
“Canada” => [ "Toronto", "Ottawa", "Montreal", "Windsor", ],
# etc
);

### Observe que a sintaxe mudou de um codigo para o outro.
### Observe os “[]”

O simbolo “[]” em torno da lista faz toda a diferenca aqui. Ele retorna uma
referencia para a lista e nao a lista em si. E como toda referencia eh do
tipo scalar, e o valor da key de um hash so pode ser um scalar, o CODIGO2
funciona perfeitamente.

— Sintaxe:

Para usar referencias em Perl eh necessario se familiarizar com uma serie de
sintaxes. Entenda-a-a-as. Estude-a-a-as. Decore-a-a-as. Na duvida, consulte
o man. Lembre-se de que voce nao estara sozinha(o) nesse momento dificil.

- Para criar um arrayref, use [ ]

Ex.:

my $idades = [ 15, 31, 22, 12 ];

- Para criar um hashref, use { }

Ex.:

my $capitais = {
Brasil => “Brasilia”,
Canada => “Ottawa”,
Alemanha => “Berlin”,
};

- Para criar uma referencia de uma variavel ja existente, use \ na frente
dessa variavel:

Ex.:

my @idades = ( 15, 31, 22, 12 );
my $idades_ref = \@idades;

my %capitais = (
Brasil => “Brasilia”,
Canada => “Ottawa”,
Alemanha => “Berlin”,
);
my $capitas_ref = \%capitais;

- Para acessar os valores dentro de uma referencia

Ex. de leitura:

print “O elemento 2 do array idades eh $idades_ref->[2]\n”;
print “A capital da Alemanha eh $capitais_ref->{Alemanha}\n”;

Ex. de gravacao:

$idades_ref->[1] = 54;
$idades_ref->[5] = 30;
$capitais_ref->{Dinamarca} = “Copenhagen”; # criando uma nova
key no hash
$capitais_ref->{Brasil} = “Brasilia, DF”; # alterando uma key
existente

— Outras formas de usar referencias (Perl references e as perl functions
push e keys)

- Exemplo sem o uso de referencias (como ja visto nas aulas anteriores):

push( @idades, 77 );

foreach my $pais ( keys %capitais ) {
print “Pais: $pais\n”;
}

- Exemplo com o uso de referencias:

push ( @$idades_ref, 77 );

foreach my $pais ( keys %$capitais_ref ) {
print “Pais: $pais\n”;
}

### MUITA atencao com os simbolos!!!
### Observe que voce precisa saber que tipo de referencia eh a variavel para
saber qual simbolo usar:

Se for array, use @:
@$array_ref

Se for hash, use %:
%$hash_ref

— Usando como exemplo de estrutura de dados, a estrutura do arquivo
/etc/passwd (vista na aula passada):

login:senha:uid:gid:gcos:home:shell

- Exemplo de conteudo do /etc/passwd:

root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin

- Cada linha do /etc/passwd eh um registro e cada registro tem varios
campos. Organizando esses registros em uma lista, temos como exemplo a
estrutura:

my @passwd = (
{
‘login’ => ‘root’
‘passwd’ => ‘x’,
‘uid’ => ‘0′,
’shell’ => ‘/bin/bash’,
‘home’ => ‘/root’,
‘gcos’ => ‘root’,
‘gid’ => ‘0′,
},
{
‘login’ => ‘bin’
‘passwd’ => ‘x’,
‘uid’ => ‘1′,
’shell’ => ‘/sbin/nologin’,
‘home’ => ‘/bin’,
‘gcos’ => ‘bin’,
‘gid’ => ‘1′,
},
{
‘login’ => ‘daemon’
‘passwd’ => ‘x’,
‘uid’ => ‘2′,
’shell’ => ‘/sbin/nologin’,
‘home’ => ‘/sbin’,
‘gcos’ => ‘daemon’,
‘gid’ => ‘2′,
},
);

- O codigo necessario para chegar nessa estrutura:

###

exemplo();

sub exemplo {
my $users_ref = ler_passwd();
exibir_usuarios($users_ref);
}

sub ler_passwd {
my $file = ‘/etc/passwd’;
my $fh;
my @users;

# abre arquivo /etc/passwd
open( $fh, “<”, $file ) || die “Erro ao abrir arquivo $file: $!”;

while (<$fh>) {

chomp;
my %user;
@user{qw( login passwd uid gid gcos home shell )} = split( /:/, $_
);

push( @users, \%user );
}

close($fh);
return \@users;
}

sub exibir_usuarios {
my ($users_ref) = @_;

foreach my $user (@$users_ref) {
print “O usuario de ID $user->{uid} e’ o $user->{login} e tem home
em $user->{home}\n”;
}
}

###

— Debugging referencias

- Usando o exemplo anterior, carregue o modulo Data::Dumper e faca a
seguinte alteracao:

sub exemplo {
my $users_ref = ler_passwd();
#exibir_usuarios($users_ref);
print Dumper $users_ref;
}

Rode o programa e veja o resultado.

### O modulo Data::Dumper serve para exibir a estrutura completa de uma
variavel, inclusive referencias.

*** Exercicios:

- Dada a estrutura de dados:

my $pessoas = [
{
nome => "Fulano de Tal",
endereco => "Avenida Rua Bairro, 1234",
cidade => "Sao Paulo",
idade => 37,
telefones => {
celular => "907-123-4567",
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},
{
nome => “Beltrano de Tal”,
endereco => “Avenida Rua Bairro, 87654″,
cidade => “Guarulhos”,
idade => 24,
telefones => {
trabalho => “416-888-3245″,
casa => “416-567-6767″,
},
filhos => [
{
nome => "Beltraninha Baby",
idade => 2,
},
],
},
{
nome => “Ciclano”,
endereco => “Avenida Rua Bairro, 78678″,
cidade => “Sao Paulo”,
idade => 27,
telefones => { celular => “907-787-9595″, },
},
];

Eh possivel fazer, por exemplo, um programa que consulta esses dados e gera
uma lista baseada em certos pre requisitos.

— EXEMPLO1: lista pessoas com idade maior que x

###

sub procurar_pessoas_com_mais_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( $pessoa->{idade} > $idade ) {
push @pessoas_encontradas, $pessoa;
}
}
exibir_pessoas( “Pessoas com mais de $idade anos”, \@pessoas_encontradas
);
# nao se preocupe com esta funcao ainda, apenas entenda que ela vai
exibir pessoas
}

###

— EXEMPLO2: lista pessoas com filhos cuja idade eh menor que x

###

sub procurar_pessoas_com_filhos_com_menos_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( exists $pessoa->{filhos} ) {
foreach my $filho ( @{ $pessoa->{filhos} } ) {
if ( $filho->{idade} < $idade ) {
push @pessoas_encontradas, $pessoa;
last;
}
}
}
}

exibir_pessoas( “Pessoas com filhos com menos de $idade anos”,
\@pessoas_encontradas );
}

###

— O codigo completo desse exemplo:

###

#!/usr/bin/perl

use strict;
use warnings;

exemplo();

sub exemplo {

my $pessoas = [
{
nome => "Fulano de Tal",
endereco => "Avenida Rua Bairro, 1234",
cidade => "Sao Paulo",
idade => 37,
telefones => {
celular => "907-123-4567",
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},
{
nome => “Beltrano de Tal”,
endereco => “Avenida Rua Bairro, 87654″,
cidade => “Guarulhos”,
idade => 24,
telefones => {
trabalho => “416-888-3245″,
casa => “416-567-6767″,
},
filhos => [
{
nome => "Beltraninha Baby",
idade => 2,
},
],
},
{
nome => “Ciclano”,
endereco => “Avenida Rua Bairro, 78678″,
cidade => “Sao Paulo”,
idade => 27,
telefones => { celular => “907-787-9595″, },
},
];

procurar_pessoas_com_mais_de_x_anos( $pessoas, 25 );

procurar_pessoas_com_filhos_com_menos_de_x_anos( $pessoas, 5 );

} ### sub exemplo

sub procurar_pessoas_com_mais_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( $pessoa->{idade} > $idade ) {
push @pessoas_encontradas, $pessoa;
}
}

exibir_pessoas( “Pessoas com mais de $idade anos”, \@pessoas_encontradas
);
}

sub procurar_pessoas_com_filhos_com_menos_de_x_anos {
my ( $pessoas, $idade ) = @_;

my @pessoas_encontradas;
foreach my $pessoa (@$pessoas) {

if ( exists $pessoa->{filhos} ) {
foreach my $filho ( @{ $pessoa->{filhos} } ) {
if ( $filho->{idade} < $idade ) {
push @pessoas_encontradas, $pessoa;
last;
}
}
}
}

exibir_pessoas( “Pessoas com filhos com menos de $idade anos”,
\@pessoas_encontradas );
}

sub exibir_pessoas {
my ( $titulo, $pessoas ) = @_;

print “\n### $titulo\n”;

foreach my $pessoa (@$pessoas) {
print “$pessoa->{nome} mora em $pessoa->{cidade} e tem
$pessoa->{idade} anos”;
if ( exists $pessoa->{filhos} ) {
print ” e tem ” . scalar( @{ $pessoa->{filhos} } ) . ”
filho(s)”;
}
print “\n”;
}
}

###

- Exercicio 1: execute o programa de exemplo acima.
- Exercicio 2: use o Data::Dumper para imprimir o conteudo da referencia
$pessoas
- Exercicio 3: crie funcoes de busca para listar:

a) Listar pessoas com endereco cujo numero da rua termina em 4
b) Listar pessoas que possuem telefone celular
c) Listar pessoas cujo prefixo do telefone residencial seja 416

- Exercicio 4: Edite o codigo de exemplo e adicione comentarios ao lado de
cada variavel da estrutura $pessoas, identificando de que tipo elas sao.

Ex.:

my $pessoas = [ # array ref
{
nome => "Fulano de Tal", # scalar
endereco => "Avenida Rua Bairro, 1234", # scalar
cidade => "Sao Paulo",
idade => 37,
telefones => { # hashref
celular => "907-123-4567", # scalar
trabalho => "907-444-3241",
casa => "416-555-9999",
},
filhos => [
{
nome => "Fulaninho Jr.",
idade => 4,
},
{
nome => "Fulaninha",
idade => 9,
},
],
},

## Perl Tutorial – Parte 4 ###

Perl style; modules, functions e regexps uteis para tarefas de administracao
de sistemas

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula nao cobre todas
as informacoes sobre Perl functions, style ou modules. Para obter
informacoes detalhadas e completas sempre acesse a documentacao do Perl.

*** Documentacao especifica:

- Digite na linha de comando:

$ man perlstyle
$ man perlfunc
$ man perlretut
$ man perlvar
$ man perlipc

*** TMTOWTDI – There’s More Than One Way To Do It.

Cada programador tem a sua preferencia na hora de escrever um codigo. Porem
ha algumas recomendacoes gerais que farao com que o seu programa seja mais
facil de ler/entender/debugar/manter. E tao importante quanto saber escrever
um bom codigo eh saber como debugar um codigo.

Recomendacoes gerais:

- o uso dos modulos strict e warnings # como ja foi stressed varias
vezes durante o curso
- uso do modulo diagnostics # para uma explicacao mais
detalhada de um warning, se necessario
- identacao # para a legibilidade
do codigo
- uso do pertidy # para reformatar um
codigo de acordo com a sua preferencia

E lembrem-se, criancas, nao eh porque voce PODE escrever algo em Perl de uma
determinada forma, que voce DEVE escreve-lo dessa forma. O Perl permite
varias formas de se escrever um codigo para uma mesma funcionalidade.
Considere escolher a forma que eh melhor legivel.

*** Perl para sysadmins

— Antes, algumas consideracoes…

- Muita gente (sim, inclusive profissionais de IT) confundem administrador
de sistemas com administrador de redes. Embora o nome ja seja bem auto
explicativo, vale a pena reforcar que administrador de redes, administra
redes (switches, routers, etc); e administrador de sistemas administra
sistemas (Linux, Sun Solaris, MS-Windows, etc). Funcoes completamente
diferentes que exigem conhecimentos diferentes.

- O Perl eh uma ferramenta muito util tanto para adm de redes quanto de
sistemas, mas nessa aula o foco eh o uso do Perl para adm de sistemas.

- Sim, considere usar Perl na hora de criar um programa para automatizar uma
tarefa em vez de usar shell script.

— E alguns exercicios:

A) Escreva um programa que le a saida do “netstat -na” e mostra quantas
conexoes estao estabelecidas (ESTABLISHED) e listening (LISTEN).

B) Faca um programa que coleta informacoes de performance da maquina a cada
10 segundos e salva o resultado num arquivo CSV, no seguinte formato:

unixtime,hostname,loadavg 1min,memtotal,memfree,buffers+cached,swapused

## dica: use como fonte de dados os arquivos:

/proc/loadvg
/proc/meminfo

C) Faca um programa que acessa uma pagina via HTTP e mostra o tempo em
milisegundos que levou para ser acessada. A URL deve ser passada via linha
de comando. Dica: use os modulos Socket, IO::Handle, IO::Socket e
Time::HiRes.

D) Altere o programa anterior e crie um loop onde o programa pergunta a URL
a ser testada ao inves de receber via linha de comando. Quando o usuario
digitar “quit”, saia do loop.

## dica: como falar HTTP:

Exemplo: acessando http://www.exemplo.com/pagina.html
apos se conectar num servidor HTTP, o client deve enviar:

GET /pagina.html HTTP/1.0
Host: www.exemplo.com
(seguido de duas linhas em branco)

Voce pode testar isso usando o comando “telnet www.exemplo.com 80″.

— Nota: as informacoes necessarias para escrever os codigos dos exercicios
estao nesta aula e nas aulas anteriores.

*** Variaveis especiais

As boas e velhas variaveis especiais do Perl.

%ENV
O hash %ENV contem as variaveis de ambiente do seu shell.

- Exemplo:

print $ENV{HOME};
print $ENV{PATH};

- Testando:

Crie um programa que imprime o conteudo do hash %ENV.

@ARGV
O array @ARGV contem os argumentos passados via linha de comando para o
script que esta sendo rodado.

- Exemplo:

Se voce rodar na linha de comando algo como:

./programa.pl argumento1 argumento2

O conteudo de $ARGV[0] sera argumento1 e o conteudo de $ARGV[1] sera
argumento2.

Note que o array @ARGV contem apenas os argumentos, ou seja, aquilo que vem
depois do nome do programa. A variavel especial que contem o nome do
programa em si eh $0.

- Testando:

Crie um programa em perl que imprime o conteudo do array @ARGV. Rode o
programa na linha de comando passando varios argumentos diferentes.
Experimente tbm com parametros como:

./programa.pl argumento1 “argumento2 argumento3″ foo\ bar

*** Lendo dados digitados pelo usuario

STDIN – entrada padrao

- Exemplo

# blah.pl:
print “\n digite algo: \n”;
my $info = <STDIN>;
print “\n Voce digitou: \n $info\n\n”

- Testando:

Rode o blah.pl. Depois rode novamente das seguintes formas:

date | ./blah.pl
uptime | ./blah.pl

*** Executando commandos do sistema

— Funcao: system

— Sintaxe: system COMANDO

— Exemplo:

system “gzip arquivo.txt”

— Notes:

- A funcao system faz um fork antes de executar o comando passado como
parametro e o processo pai espera ate que o processo filho seja finalizado.

- Tenha em mente que o Perl esta a merce do OS no qual ele esta rodando.
Para usar a funcao system, lembre-se de levar em consideracao em qual
sistema o seu programa ira rodar para definir qual o comando a ser passado
como parametro.

- Use o system somente quando necessario. Tenha em mente que o perl tem
varias builtin functions para tratamento de files, como por exemplo:

mkdir
rmdir
chmod
rename
chdir
umask
utime

entre outras…

- Antes de usar a funcao system, consulte o man do perl para verificar se
nao ha uma buitin function do Perl que faz exatamente o que voce quer:

$ man perlfunc

- Para consultar o man de uma funcao especifica:

$ perldoc -f nome_da_funcao

— Funcao: open

— Sintaxe: open $fh, “COMANDO|”

— Exemplo:

open my $fh, “ps uxaw|” or die “Erro ao executar comando: $!\n”;
while (<$fh>) {
print “saida do ps: $_”;
}
close $fh;

— Notes:

Note que a sintaxe do open usada neste exemplo eh um pouco diferente das
sintaxes usadas nas aulas anteriores. O | pipe no final do comando faz com
que ele rode o comando e capture a saida padrao dele.

*** Conectando numa porta TCP

— Funcoes:

socket
connect

— sintaxe:

socket SOCKET,DOMAIN,TYPE,PROTOCOL
connect SOCKET,NAME

— Exemplo:

#socket_exemplo.pl

use Socket;
use IO::Handle;

my $host = shift; # le o parametro passado na linha de comando
my $port = 80;

my $ip_addr = inet_aton($host) or die “host unknown: $host”;
my $paddr = sockaddr_in( $port, $ip_addr );
my $proto = getprotobyname(‘tcp’);
socket( my $socket, PF_INET, SOCK_STREAM, $proto ) or die “socket: $!”;
connect( $socket, $paddr ) or die “connect: $!”;

autoflush $socket;

print $socket “GET / HTTP/1.0\r\nHost: $host\r\n\r\n” or die “print: $!”;

while ( my $line = <$socket> ) {
print “got $line”;
}

close $socket;

— Testando:

./socket_exemplo.pl exemplo.com

*** Expressoes Regulares

— Exemplo para ler e tratar a saida do comando netstat -na

my %count_of;

open my $fh, “netstat -na|” or die “Erro ao executar netstat -na: $!”;
while (<$fh>) {
next if ! /^tcp /;
if ( /\s+(LISTEN|ESTABLISHED)/ ) {
my $qual = $1;
$count_of{$qual}++;
}

}

print ” LISTEN: $count_of{LISTEN}\n”;
print ” ESTABLISHED: $count_of{ESTABLISHED}\n”;

— Notes:

/(LISTEN|ESTABLISHED)/; # da match em LISTEN ou ESTABLISHED

## Perl Tutorial – Parte 5 ###

Fim da 2a parte do Curso de Perl – Overview das ultimas aulas e informacoes
adicionais para referencia; como criar modulos

ATENCAO:
Esta aula faz parte do curso Perl Tutorial e eh continuacao do curso Perl
Intro, tambem disponibilizado no LinuxChix.org.br. Esta aula eh um overview
do que ja foi ensinado nessa fase do curso e de forma alguma cobre todas as
informacoes disponiveis sobre Perl.

*** O que foi abordado nessa fase do curso:

— Perl best practices

- Uso dos modulos strict e warnings
- Formatacao de codigo (definicao de padroes; uso do perltidy)
- Perl style
- Como acessar a documentacao especifica

— Perl modules

- O que eh
- Como instalar (manualmente e usando o modulo CPAN)
- Como usar
- Como acessar a documentacao especifica

— Code debugging

- Uso do modulo diagnostics
- Uso do modulo Data::Dumper

— Perl builtin functions

- Funcoes para tratamento de strings
- Funcoes para tratamento de listas
- Funcoes para manipulacao de arquivos e diretorios
- Funcoes para controle de loops
- Como acessar a documentacao especifica

— Referencias em Perl

- O que eh
- Sintaxe
- Como usa-las para lidar com estruturas de dados mais complexas
- Como acessar a documentacao especifica

— Perl para sysadmins

- Uso do Perl para automatizar tarefas de administracao de sistemas
- Variaveis especiais
- Como receber dados via linha de comando
- Como executar comandos do sistemas usando Perl
- Funcoes uteis para manipulacao de files
- Como se conectar numa porta TCP
- Modulos uteis
- Como acessar a documentacao relacionada

*** Infomacoes adicionais:

— Variaveis especiais

$_ variavel default
@_ argumentos passados para uma subrotina/funcao
$0 nome do programa sendo rodado
@ARGV argumentos passados na linha de comando
%ENV variaveis de ambiente (environment)
@INC path usado pelo Perl para procurar os modulos
$$ ID do processo
$! msg de erro da ultima funcao executada
$| autoflush

$ man perlvar

— Referencias

my $scalar_ref = \$scalar; # retorna a referencia do scalar $scalar
my $array_ref = \@array; # retorna a referencia do array @array
my $hash_ref = \%hash; # retorna a referencia do hash %hash
$$scalar_ref; # dereference um scalar
@$arrayref; # dereference um array
%$hashref; # dereference um hash
my $array_ref = [ ... , ... , ... ]; # cria um arrayref
my $hash_ref = { key => value, … }; # cria um hashref

$ man perlreftut

— Modulos uteis

strict
warnings
diagnostics
Data::Dumper
IO::Handle
IO::Socket
Socket
Exporter
Time:HiRes
DBIx::Class
Storable
LWP::UserAgent
File::Path
HTML::Parser

— Sempre faca:

use strict;
use warnings;
my $variavel; # sempre declare variaveis
open(…) or die $!; # teste o retorno de todas funcoes

- use Perl modules (consulte o CPAN)
- teste o retorno de um comando/funcao
- use variaveis com nome intuitivos
- evite criar variaveis globais
- use perltidy

*** Exercicio: criando um modulo

Entao. Digamos que voce precisa de um modulo com determinadas funcoes e
procurou no CPAN, mas nao encontrou: voce precisara escrever o seu proprio
modulo. Veja abaixo um exemplo de como colocar suas funcoes dentro de um
modulo e como reusa-lo em varios programas.

— Crie o modulo Blah.pm, e escreva algumas funcoes no modulo, seguindo o
modelo abaixo:

package Blah; # nome deste modulo
use strict;
use warnings;
use Exporter; # modulo Perl que facilita a exportacao de funcoes
use base “Exporter”; # conforme a documentacao do Exporter

# liste as funcoes que voce quer exportar
our @EXPORT_OK = qw(
funcao1
funcao2
funcao3
);

sub funcao1 {
my ( $foo, $bar ) = @_;

return $foo * $bar;
}

sub funcao2 {
my ($blah) = @_;
return ucfirst lc $blah;
}

sub funcao3 {
my ($bleh) = @_;
return length $bleh;
}

1; # Perl modules tem que terminar retornando true

— Crie um programa programa.pl que use funcoes do modulo Blah.pm, seguindo
o modelo abaixo:

use Blah qw( funcao1 funcao2 ); # Importe apenas as funcoes que serao
usadas nesse codigo

my $var1 = funcao1( 3, 5 );

print “var1 = $var1\n”;

my $var2 = funcao2(“blAHHHhhhhHHHhhhH!”);

print “Resultado: $var2\n”;

— Rode o programa.pl

####

Fim da 2a parte do curso de Perl.

Fonte: http://www.gustavoroberto.blog.br

Related posts:

1. Curso de Perl – Como programar em Perl Nota, se você não tem acesso a um UNIX para...
2. Scripts de conexão ao MySQL – Perl Segue abaixo um exemplo simples para testar a conexão do...
3. Tutorial PERL A linguagem Perl (Practical Extraction and Report Language) - inicialmente...

Posts relacionados trazidos a você pelo Yet Another Related Posts Plugin.

Introdução

É uma linguagem de programação usada com vários propósitos: Administração de sistemas, desenvolvimento Web, administração de redes, manipulação de dados, textos, e assim por diante.

Documentação

Na linha de comando:

$ man perl

$perldoc -f nome_da_funcao

Na Web :

http://perldoc.perl.org

http://www.google.com.br ( O google sempre ajuda, é só perguntar a ele ).

Rodando programas escritos em Perl na linha de comando.

Obs : Ao escrever um programa em Perl, é interessante que coloquemos a extensão .pl, mas só por enquanto, para podermos lembrar.

Para rodar o programa é simples, basta digitar o nome do interpretador, seguido do nome do programa , exemplo:

$ perl programa1.pl

Sintaxe

Todos os statements terminam com um “;”

Exemplo:

print “Blah, blah, blah”;

Para comentar uma linha, use “#”

Exemplo:

# Isso é um comentario

print “Blah, blah, blah”; # isso também é um comentário

Variáveis

Em perl, existe basicamente 3 tipos de variáveis: scalar, array e hash.

Importante: Você não precisa especificar o tipo de dado que você está guardando dentro de uma variável. Você pode, por exemplo guardar um número e depois guardar um texto que o Perl vai saber como lidar com isso.

scalar : É representado pelo símbolo “$” e é usado para guardar valores simples, como por exemplo: uma palavra, um texto ou números, uma data, etc.

my $fruta = “laranja”;
print “$fruta\n”;

my $total = 24;
my $resultado = $total / 2;
print “$resultado\n”;

array : É representado pelo símbolo “@” e é usado para guardar uma lista de valores.

my @frutas = (“laranja”, “manga”, “banana”);
my @numeros = (10, 45, 20, -78, 99.9, 14);
my @tudo = (“laranja”, 100, 24, “manga”, 5);

my @numeros;
$numero[0] = 10;
$numero[1] = 45;
$numero[2] = 20;
$numero[3] = -78;

Para acessar os elementos de um array, são usados os índices:

print $frutas[0]; # vai imprimir laranja
print $frutas[1]; # vai imprimir manga

Para acessar o último elemento de um array, use $#array_name:

print $frutas[$#frutas]; # vai imprimir banana, que eh o ultimo elemento do
array

hash: É representado pelo simbolo “%” e é usado para guardar uma lista
de valores, assim como o array. O diferencial é que o indice de um array
tem que ser um número. E o indice do hash pode ser um número ou um texto.

Exemplo:

my %idades = ();

$idades{Fulano} = 21;
$idades{Beltrano} = 59;
print “O Fulano tem $idades{Fulano} anos, mas o Beltrano tem
$idades{Beltrano}\n”;

Agora o famoso programa Hello World ! Escrito em Perl:

#!/usr/bin/perl
use strict;
use warnings;

my $texto = “Hello, World!”;
print $texto,”\n”; # imprime Hello, World!

Notas:

1. Tente rodar o programa hello world descrito acima.

2. Sempre começe seu programa em Perl com as seguintes três linhas:

#!/usr/bin/perl
use strict;
use warnings;

Sempre declare as variáveis usando o “my” antes de usa-las ou na primeira
vez que usa-las, exemplo:

my $variavel;
$variavel = “123 testando”;
print “$variavel\n”;

ou então:

my $variavel = “123 testando”;
print “$variavel\n”;

NÃO declare a variável mais de uma vez, como por exemplo:

my $variavel;
my $variavel = “123 testando”;

3. Exercícios:

Crie programas simples de declaração e impressão de variáveis, como por
exemplo:

a) crie um array de 5 elementos e imprima o primeiro e o último elemento;
b) crie um hash cujos indices sejam países e os valores sejam as suas
respectivas capitais. Imprima alguns dos valores;

Operadores, condições e estruturas de repetição – Introdução

Operadores

O Perl tem inúmeros operadores. Os mais comumente usados são:

Matemática:

+ adição
- subtração
* multiplicação
/ divisão
% resto da divisão

Exemplos:

my $x = 5;
my $y = 1.9;
my $z = $y / 2;
my $soma = $x + $y * 3 / $z;
print “Soma: $soma\n”;

my $x = 22;
my $y = 5;
my $resto = 22 % 5;
print “Resto: $resto\n”;

Operadores para comparação numérica:

== igual
!= diferente
maior que
= maior ou igual a

Sintaxe:

if ($numero1 == $numero2) {
…
}

Operadores para comparação de texto:

eq equivalente
ne diferente

Sintaxe:

if ($texto1 eq $texto2) {
…
}

Operadores para comparação lógica:

&& e
|| ou
! negação

Exemplo:

if ( ($numero1 == $numero1) && ($texto1 eq $texto2) ) {
…
}

if ( !($numero1 == $numero2) ) {
…
}

Condições

IF ELSIF ELSE

if (condicao) {

…

} elsif (outra condicao) {

…
} else {

…
}

OU

… if condicao;

Exemplo:

my $sisop = ‘linux’;

if ($sisop eq “solaris”) {

print “Solaris\n”;

} elsif ($sisop eq “linux”) {

print “Linux\n”;

} else {

print “Outro sistema operacional\n”;
}

OU

my $valor = 30;
print $valor if ($valor = 30); #imprime valor SE o valor for igual a 30

UNLESS – eh a negativa do IF.

Sintaxe:

… unless (condicao);

Exemplo:

my $valor = 30;
print $valor unless ($valor = 30); #imprime valor A NÃO SER QUE valor seja
igual a 30

Estruturas de repetição

WHILE: a repeticao continua enquanto “condicao” não for verdade.

Sintaxe:

while (condicao) {
…
}

OU

… while condicao;

Exemplo:

my $contador = 0;
while ($contador 10) {
print “Contando ate 10 com until… $contador\n”;
$contador++; #incrementa contador
}

FOR: é exatamente como na linguagem C. Geralmente nao é muito usado em
Perl, já que o Perl tem uma outra estrutura – o FOREACH – que é muito mais
pratica que o FOR.

for (inicia contador; condicao; incrementa contador) {
…
}

Exemplo:

my $fim = 10;
for ( my $contador=0; $contador “MySQL”,
linguagem => “Perl”,
webserver => “Apache”,
);
foreach my $ferramenta (keys %desenvolvimento) {
print “O Conteudo de $ferramenta eh
$desenvolvimento{$ferramenta}\n”;
}

Exercícios

Para se familiarizar com as estruturas e sintaxes do Perl, crie programas
simples com loops, condições e comparações como por exemplo:

a) crie um array com vários elementos numéricos e imprima somente os números
maiores que 10;

b) crie um array com vários elementos numéricos e imprima somente os números
pares e maiores que 10;

c) crie um array com varios elementos do tipo texto e use foreach para
imprimi-los.

d) crie um programa que contenha as seguintes linhas:

my $resultado = “linux ” x 5;
print “O resultado de linux x 5 eh igual a $resultado\n”;

e veja como funciona a multiplicação de texto.

Tratamento de arquivos e expressões regulares:

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos” e “expressões regulares”. Esses
assuntos serão abordados por várias outras aulas no decorrer do curso. Quem
precisa desesperadamente de mais informações e não pode esperar até que eles
sejam abordados, pode acessar os manuais do Perl, conforme descrito na
primeira aula.

Tratamento de arquivos:

Basicamente o tratamento de arquivos segue a estrutura:

- abre arquivo para escrita e/ou leitura E testa se o arquivo foi aberto
- escreve e/ou le o arquivo
- fecha arquivo

A função open() é utilizada para abrir arquivos, tanto para leitura como
para escrita. E a função close() é usada para fechar os arquivos que foram
previamente abertos.

ABRINDO ARQUIVOS:

Para abrir um arquivo para leitura, pode-se usar algo como:

open(my $arquivo, “/path/do/arquivo.txt”)

NOTA: O símbolo “>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever por cima do que já estiver escrito dentro do
arquivo.

Para abrir um arquivo para escrita (concatenando no final), pode-se usar
algo como:

open(my $arquivo, “>>/path/do/arquivo.txt”)

NOTA: O símbolo “>>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever concatenando o texto no final no arquivo.

TESTANDO SE O ARQUIVO FOI ABERTO:

Para testar se o arquivo foi aberto, pode-se usar algo como:

open(my $arquivo, “) { # le cada linha do arquivo e grava o
conteudo na variavel $linha
print $linha; # imprime o conteudo de $linha
}

Ou então:

while () { # faz um loop lendo uma linha do arquivo de cada vez
e gravando na variavel especial $_
print; # o “print” sozinho eh a mesma coisa que “print $_”
}

Não é magica. Quando nenhuma variavel eh especificada, o Perl usa a
variável especial $_

Sendo assim, na linha do while esta implícito, mas o Perl está gravando cada
linha linha na variável $_ e na linha do print, também está implícito, o Perl
está dando um print na variável $_

ESCREVENDO EM UM ARQUIVO:

Quando um arquivo eh aberto para escrita, como nos exemplos:

open(my $arquivo, “>/path/do/arquivo.txt”);

ou:

open(my $arquivo, “>>/path/do/arquivo.txt”);

Para escrever algo nesse arquivo, pode-se usar algo como:

print $arquivo “1 \n”;
print $arquivo “2 \n”;
print $arquivo “3 \n”;
print $arquivo “4 \n”;

Ou, melhor:

foreach my $numero (1..4) {
print $arquivo “$numero\n”;
}

FECHANDO UM ARQUIVO:

— A função close() é usada para fechar o arquivo que foi aberto tanto
para leitura, como para escrita.

close $arquivo;

Exemplo 1: Lendo o conteúdo de um arquivo:

- Crie um arquivo chamado paises.txt, com o seguinte conteúdo (um país em
cada linha):

Alemanha
Brasil
Dinamarca
Estados Unidos
Inglaterra

- Crie no mesmo diretório onde está o arquivo paises.txt, um programa
chamado paises.pl e copie o seguinte código dentro dele:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

- O programa irá gerar o seguinte output:

Nome do país: Alemanha

Nome do país: Brasil

Nome do país: Dinamarca

Nome do país: Estados Unidos

Nome do país: Inglaterra

Exemplo 2: Escrevendo em um arquivo:

- Para escrever em um arquivo, crie um programa chamado esportes.pl, com o
seguinte conteúdo:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;
my @esportes = (“hockey”, “futebol”, “tennis”, “levantamento de peso”,
“baseball”);
print $arquivo “Criando um arquivo em Perl… \n”;
foreach my $esporte (@esportes) {
print $arquivo “Nome do esporte: $esporte\n”;
}
print $arquivo “Fim do arquivo… \n\n”;
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

Confira o conteúdo de esportes.txt, que será algo como:

Criando um arquivo em Perl…
Nome do esporte: hockey
Nome do esporte: futebol
Nome do esporte: tennis
Nome do esporte: levantamento de peso
Nome do esporte: baseball
Fim do arquivo…

Expressões Regulares – ou simplesmente “regexp”:

Muita calma nessa hora: Regexps tem fama de serem difíceis e muito
complicadas. Mas a partir do momento que você entende a idéia geral e as
coisas básicas sobre regexps, fica bem mais fácil ir acrescentando
informações e conseguir fazer regexps mais elaboradas.

O que eh uma regexp?

Regexp é um texto que descreve um padrão, um modelo. Por exemplo, é comum
usarmos na linha de comando do linux, algo como: “ls *.pdf”, o que vai
retornar todos os arquivos com extensão “.pdf”. Em Perl existem as chamadas
expressões regulares, que servem para (entre outras coisas que serão
abordadas nas próximas aulas) procurar um determinado padrão dentro de um
texto.

Vejamos através de exemplos:

Vamos pegar o primeiro dos programas de exemplo citado acima:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

Imagine que você não sabe qual é o conteúdo do arquivo paises.txt, e você quer
imprimir apenas os países cujo nome contem a letra “m”. Para isso,
poderíamos transformar o programa acima em algo como:

#!/usr/bin/perl
use warnings;
use strict;

open (my $arquivo, “) {
if ($_ =~ /m/) { # verifica se o nome do pais contem a letra
m
print “Pais que contem a letra m: $_ \n”;
} else {
print “Pais que NAO contem a letra m: $_ \n\n”;
}
}
close $arquivo;

Analisando o programa de exemplo:

if ($_ =~ /m/) {

O $_ ja foi descrito no começo dessa aula: é uma variável especial do Perl,
muito útil e bastante usada. No caso do programa acima, o conteúdo de $_ é
a linha do arquivo previamente lida durante o statement “while
()”.

=~ é o operador usado para comparar o conteúdo da variavel com a regexp

m eh a regexp (nesse caso, a regex é um texto simples, mas uma regexp pode
ser muito mais complicada do que isso)

Os // no começo e no fim da regexp indica que a letra m será procurada no
conteúdo da variável $_

Em outras palavras o que o programa faz é: verificar se a variável $_
contem a palavra “m”.

Outros exemplos:

my $texto = “Ola Mundo”;
$texto =~ /mundo/; # nao vai dar match pq regexps sao case sensitive.
$texto =~ /a M/; # vai dar match pq espacos sao tratados como qq
outro caractere.
$texto =~ /aM/; # nao vai dar match pq esta faltando o espaco
$texto =~ /Mundo /; # nao vai dar match por causa do espaco no final

Exercicios:

a) Utilizando o programa de exemplo 2: troque a linha:

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

por:

open (my $arquivo, “>>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

Rode o programa várias vezes. Veja o que acontece com o conteúdo do arquivo
esportes.txt.

b) Exercício terapeutico: Seguindo o programa de exemplo 1 como modelo, crie
um arquivo chamado chatos.txt e coloque nesse arquivo o nome de vários
chatos, um por linha. Faça um programa (chatos.pl) que imprima os nomes dos
chatos.

c) Em Perl, em alguns casos, é possível se imaginar para que serve uma
função baseado no nome da função. Por exemplo: função die – mata o programa;
função use – carrega um módulo, avisa o Perl para “usar” um determinado
módulo. Existe uma função muito útil para ser usada, entre outras coisas,
quando se lê um dado de um arquivo: chomp. Utilizando o programa de chatos
que vc acabou de criar, tente descobrir para que serve o chomp. Tente, por
exemplo:

troque as linhas:

while () {
print “Esse fulano eh um chato: $_ \n”;

por:

while () {
chomp;
print “Esse fulano eh um chato: $_ \n”;

NOTA: Obviamente, só faça esse exercício se você não sabe para que serve o
chomp. Para quem quiser mais informações sobre o chomp: digite na linha de
comando: perldoc -f chomp

d) Ainda utilizando o seu programa de chatos, faça testes com ele: imprima
somente os nomes dos chatos que contém um espaço, que contem a letra m
(maiúscula, depois minúscula), etc.

e) Tente abrir para leitura ( ou >>) um arquivo que não existe. Use o
programa de esportes, por exemplo: apague o arquivo esportes.txt e tente
rodar o programa esportes.pl. Veja o que acontece.

Tratamento de Arquivos, Expressões Regulares e Subrotinas/Funções

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos”, “expressões regulares” e
“subrotinas/funções”. Esses assuntos serão abordados também em outras aulas
no decorrer do curso. Quem precisa desesperadamente de mais informações,
pode acessar os manuais do Perl, conforme descrito na primeira aula.

Ainda sobre o tratamento de arquivos.

Na última aula foi descrito como manipular arquivos para leitura e escrita.
Foram descritas algumas funções nativas do Perl que podem ser usadas para o
tratamento de arquivos, como as funções open e close.

RELEMBRANDO:

- O símbolo é usado para abrir o arquivo para escrita, sobrescrevendo o
conteúdo do arquivo

- O simbolo >> é usado para abrir o arquivo para escrita, acresentando ao
final do arquivo.

ACRESCENTANDO MAIS ALGUMAS INFORMAÇÕES:

- Se o simbolo é omitido, o Perl interpreta que o arquivo está sendo aberto
para leitura.

Exemplo:

open(my $arquivo, “/path/do/arquivo.txt”)

O trecho de código acima, abre o arquivo arquivo.txt para leitura, ou seja,
é a mesma coisa que:

open(my $arquivo, ”
=

Os operadores para comparacao de strings:

eq
ne

Os operadores para comparação lógica:

&&
||
!

As estruturas de condição:

if
elsif
else
unless

As estruturas de repetição:

while
until
for
foreach

Tratamento de arquivos:

- como abrir e ler o conteudo de um arquivo
- como criar/abrir e escrever em um arquivo
- como alterar o conteudo de um arquivo
- como testar se o arquivo foi aberto
- como fechar o arquivo

Expressões regulares:

- como procurar por um padrao em um texto
- como substituir um padrao em um texto

Subrotinas/funções:

- como criar funcoes
- como executar funcoes

NOTA: Quem acompanhou o curso até aqui, supostamente já conhece pelo menos o
básico do que foi descrito acima. Caso você não se lembre de alguma coisa,
revise o conteúdo das aulas anteriores.

Mais informacões sobre expressões regulares:

Back Reference

Back references sao usadas para pegar informacoes especificas de um texto.

Exemplo 1:

Digamos que um programa recebe a seguinte informação:
“hora=10:20,data=25/12/2005″ e que precisamos isolar o dia o mês e o ano em
variáveis diferentes. Podemos usar algo como:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

$dia = $1;
$mes = $2;
$ano = $3;
print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Ou então:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $1\n”;
print “Mes = $2\n”;
print “Ano = $3\n”;
}

Ou ainda:

my $info = “horario=10:20,data=25/12/2005″;

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Analisando trechos do programa:

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e guarda os valores entre parentêses nas back
references. Ou seja, o conteúdo da variável $info que da match nas regexps
entre parentêses, são gravadas nas variáveis especiais $1, $2 e $3
respectivamente.

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e atribui os valores referentes as regexps entre
parentêses para as variáveis $dia, $mes, $ano respectivamente.

Escopo das variáveis: observe que o “my” foi usado dentro de um “if”. Nesse
caso, as variáveis $dia, $mes e $ano, só existem dentro daquele “if”.

Traduzindo a regexp:

m|^.*data=(\d{2})/(\d{2})/(\d{4})|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.

.* “ponto” eh qualquer caractere; “asterisco” indica nenhuma ou mais
ocorrências do caractere anterior. Ou seja, nessa regexp de exemplo, .*
significa: nenhuma ou mais ocorrências de qualquer caractere.

data= neste exemplo, é literalmente o texto “data=”

\d{2} significa a ocorrência de 2 números.

(\d{2}) colocar \d{2} (ou qualquer outro trecho da regexp) entre parentêses,
significa que o conteúdo de variável que der match nesse trecho, estará
acessivel através das back references: $1, $2, $3, $4. etc.

Em outras palavras, essa regexp verifica se:

A string começa com nenhum ou mais quaisquer caracteres seguida de: “data=”,
2 números, uma barra, 2 números, uma barra, 4 números.

Exemplo 2:

Digamos que um programa recebe a seguinte informação: “email=
cursos at linuxchix.org.br” e que precisamos isolar o usuário e o dominio.
Podemos usar algo como:

my $info = ‘email=cursos at linuxchix.org.br’;

if ( $info =~ m|^e-?mail=(.+)@(.+)| ) {

print “Usuario = $1\n”;
print “Dominio = $2\n”;
}

Analisando trechos do programa:

my $info = ‘email=cursos at linuxchix.org.br’;

Note que aqui foi usado ‘ (aspas simples) ao invés de ” (aspas). Isso
porque, em Perl, quando usamos “, significa que o Perl vai interpretar tudo
o que esta dentro de ” (aspas), inclusive variáveis. Então, no exemplo
acima, se fizermos algo como:

my $info = “email=cursos at linuxchix.org.br”;

O Perl vai interpretar o @linuxchix como se isso fosse um array e nao como
se isso fosse um texto qualquer.

Quando usamos ‘ o Perl não tenta interpretar o conteudo entre ‘ (aspas
simples), então podemos usar o sinal @ sem problemas.

Traduzindo a regexp:

m|^e-?mail=(.+)@(.+)|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.