Transferir scripts Perl do Solaris para Linux

Com avanços nas tecnologias de visualização, as empresas estão
consolidando servidores físicos para ambientes virtualizados,
aprimorando, assim, o gerenciamento de ativos enquanto reduz o consumo de
energia e o espaço físico.

Em alguns casos, movimentos de consolidação
envolvem migrar de um sistema operacional antigo para um que possa
fornecer manutenção do sistema mais fácil ou outros benefícios de Custo
Total de Propriedade.

Se estiver planejando migrar do Solaris para o Linux,
quase todos os seus códigos customizados (incluindo C, shell scripts,
Perl, etc.)
precisarão de algum tipo de correção, um “realinhamento” de atributos de mapeamentodevido às diferenças das plataformas.

Além disso, Perl não é diferente de outras linguagens. Apesar de o
próprio programa ser portátil entre plataformas e de ser necessário
apenas um interpretador instalado para executar o código no sistema de
destino, alguns problemas de tipo de correção provavelmente surgirão.

Recursos específicos do Solaris, nomes de caminhos mais notáveis de
sistemas operacionais, comandos do sistema e módulos Perl são
aproveitados com frequência no código. Por isso é provável ter que
executar alguma correção de código para certificar de que os scripts
Perl funcionarão conforme desejado após a migração.

Mas o que a sintaxe Perl constrói e em quais operadores
deve-se prestar mais atenção? Neste artigo, explicamos as armadilhas
mais comuns da portabilidade e apresentamos um roteiro para migração de
scripts Perl do Solaris para o Linux.

Provavelmente, é possível utilizar o roteiro deste
artigo em migrações da maioria dos sistemas operacionais UNIX (incluindo
AIX, HP/UX, etc.) para o Linux. No entanto, todos os exemplos, códigos
de amostra e referências têm como foco migrações do Solaris para o
Linux.

Sem tempo para ler o artigo?

Aqui estão as cinco “pegadas” mais comuns para observar ao migrar scripts Perl do Solaris para o Linux:

1. Dependência de módulos Perl específica da plataforma
2. Comandos do sistema operacional e IPC (inter-process communication)
3. Nomes de caminhos aproveitados do sistema operacional
4. Variáveis especiais que contêm informações específicas da plataforma
5. Funções que são implementadas de maneira diferente ou que não são implementadas por meio de plataformas

Problemas na portabilidade do Perl

É necessário inspecionar os recursos relacionados em scripts Perl
para certificar-se de que nenhum problema devido ao código específico do
Solaris surgirá ao executá-los em um sistema Linux.

Por exemplo, pense
em um script que extrai informações de um arquivo que é encontrado
somente no Solaris. Imagine executar um comando do sistema que utiliza
um sinalizador que não está disponível no Linux.

A maioria dos problemas de portabilidade pode ser
dividida em cinco classes com base nos recursos de sistema que acessam
ou relacionam, conforme mostrado na Tabela 1.

Tabela 1. Classes de problemas de portabilidade em scripts Perl

As classes relacionadas na Tabela 1 não constituem uma lista definitiva
de todos os problemas de portabilidade, são apenas os mais comuns. Para
obter informações mais detalhadas sobre problemas de portabilidade,
consulte a Documentação de Programação Perl ( ao final do artigo, consulte a seção Recursos para obter um link).

Cinco etapas para transporte correto de Perl

Vamos observar o roteiro para transportar scripts Perl do Solaris para o
Linux. Este roteiro é compilado sobre as classes de problemas de
portabilidade da Tabela 1.

O roteiro inclui cinco etapas, cada uma com
foco em uma das classes da Tabela 1. Cada etapa identifica problemas com
construções ou operadores de sintaxe Perl que talvez necessitem de
algum tipo de correção de código.

Etapa 1: Inspecionar dependência de módulo específica do Solaris

A primeira etapa é sobre inspecionar módulos Perl importados. Alguns
deles são construídos especificamente para o Solaris e, uma vez
ativados, vincularão o script à plataforma Solaris.

É necessário
identificar esses módulos por meio do código do script, descobrir suas
funções e variáveis aproveitadas e realizar as alterações adequadas para
que você não fique vinculado a uma plataforma na qual o script Perl não
está sendo executado.

É possível encontrar uma lista abrangente de módulos específicos do Solaris no repositório CPAN. Eles geralmente têm nomes que começam com
Solaris:: ou Sun::Solaris::.

É possível utilizar o shell script da listagem 1 para
identificar arquivos de script Perl com instruções de importação que
comecem com “Solaris” ou “Sun.”

Listagem 1. Como encontrar importações de módulos do Solaris

#!/bin/bash<br />find . -name "*.pl" -exec grep -ilP "^\s*use (Solaris|Sun)" {} \;

É possível modificar o código da listagem 1 para tornar esse script
mais preciso ao encontrar módulos específicos do Solaris dentro de
scripts Perl. Por exemplo, é possível converter o shell script da
listagem 1 para Perl aproveitando assim o Módulo PPI
para análise.

A utilização desse módulo está além do escopo deste
artigo, porém, é recomendável para maior precisão ao analisar códigos
Perl.

Após identificar scripts com código específico do
Solaris, será necessário procurar módulos equivalentes que também
trabalhem no Linux. Nem sempre é fácil identificar tais módulos em
termos de funcionalidade, pois os módulos originais poderão lidar com
tecnologias exclusivas da plataforma Solaris.
Quando isso ocorrer, será necessário realizar uma análise
mais profunda.

Para utilizar um módulo equivalente baseado em Linux, será necessário substituir todas as instruções de importação e também todas as
funções e variáveis chamadas pelas equivalentes do novo módulo.

Etapa 2: Inspecionar chamadas para comandos do sistema específicos do Solaris

Chamar comandos do sistema operacional de dentro do script Perl
poderá apresentar o problema mais comum ao se realizar migrações do
Solaris para Linux por vários motivos:

• Falta de comandos no sistema de destino
• Comandos com conjunto de sinalizadores diferente
• Comandos que se comportam de maneira diferente nas duas plataformas

Portanto, será necessário ter cuidado especial ao lidar
com esse problema, o problema de portabilidade de classe número 2:
Chamadas de sistema.

O objetivo aqui é certificar-se de que qualquer comando
do sistema evocado no script de maneira sintática e semântica trabalhe
corretamente no Linux também.

Em resumo, trata-se da identificação de
funções e operadores Perl principais aproveitados no script que contém
comandos do sistema específicos do Solaris.

Vamos começar com um exemplo. A listagem 2 mostra um
script Perl simples utilizado para exibir o tamanho da memória de um
sistema Solaris. 

Listagem 2. Script Perl para exibir tamanho da memória do sistema

#!/usr/bin/perl<br />my $mem_info = `prtconf | grep Memory`;<br />my (undef, $mem_size) = split(':', $mem_info);<br />($mem_size, undef) = split(' ', $mem_size);<br />print "Memory size is: ".$mem_size."\n";

Suponha que desejamos executar o mesmo script no Linux. Descobrimos que ele chama um comando do sistema de canal
(prtconf | grep Memory) por meio do backtick do operador e do comando prtconf que é específico do Solaris. A primeira etapa é encontrar um substituto para ele.

É possível utilizar cat /proc/meminfo | grep MemTotal
mesmo apesar de a saída ser formatada de forma diferente uma vez que
/proc/meminfo contém informações de tamanho em KBs
e prtconf em MBs.

Para corrigir esse script, é possível substituir
ptrconf por
cat /proc/meminfo mas, para manter as
informações em MB (não sabemos se a saída desse script é utilizada como
entrada em outros scripts, por isso, é crítico não alterá-lo), podemos
utilizar uma conversão simples. A listagem 3 mostra um exemplo de como
esse script deverá ser corrigido.

Listagem 3. Corrigindo o script da listagem 2

#!/usr/bin/perl <br />my $mem_info = `cat /proc/meminfo | grep MemTotal`; <br />my (undef, $mem_size) = split(':', $mem_info); <br />($mem_size, undef) = split(' ', $mem_size); <br />$mem_size = int($mem_size / 1000); <br />print "Memory size is: ".$mem_size."\n";

Devido à flexibilidade do Perl ser suficiente para acomodar diferentes
maneiras de executar comandos do sistema operacional, existem muitos
operadores e funções principais diferentes utilizados com esse
propósito.

A tabela 2 relaciona operadores e funções Perl principais
aproveitados para chamar comandos do sistema dentro de um script Perl.

Tabela 2. Operadores e funções Perl principais aproveitados para chamar comandos do sistema

É possível verificar documentos Perl para obter mais informações sobre
cada um desses operadores e funções, bem como qualquer outro que não for
parte da linguagem Perl principal.

Consulte o IBM Redbook “Solaris
to Linux Migration: A guide for system administrators” para saber mais sobre diferenças em comandos de administração de sistema.

Etapa 3: Inspecionar utilização de nomes de caminhos do SO

Agora, vamos discutir sobre nomes de caminhos aproveitados pelo
script Perl. Esta etapa é semelhante à Etapa 2. Aqui será necessário
prestar atenção nos elementos de sintaxe e operadores que são utilizados
para abrir ou manipular arquivos.

Apesar de haver operadores específicos para fazer isso, alguns problemas
com nomes de caminhos relacionados poderão surgir. (Também é possível
observar isso ao invocar comandos do sistema como os mencionados na
Etapa 2).

A listagem 4 mostra um pequeno script que lê o arquivo de configuração NFS do Solaris e o imprime na saída padrão.

Listagem 4. Script Perl que imprime o conteúdo de um arquivo do sistema na saída padrão

#!/usr/bin/perl<br />open(NFSCONF, '/etc/default/nfs');<br />print <NFSCONF>;<br />close(NFSCONF);

Ao migrar do Solaris para o Linux, será necessário prestar atenção aos
caminhos do sistema, que diferem com frequência. Neste exemplo, o
arquivo /etc/default/nfs relacionado nesse script do Solaris não existe na distribuição Linux/Red Hat, porém, é substituível por /etc/sysconfig/nfs. A listagem 5 mostra o script após ser corrigido.

Listagem 5. Correção da listagem 4

#!/usr/bin/perl<br />open(NFSCONF, '/etc/sysconfig/nfs');<br />print <NFSCONF>;<br />close(NFSCONF);

É necessário estar ciente de quaisquer comandos Perl que manipulem
arquivos. A Tabela 3 mostra alguns comandos comuns de manipulação de
caminhos utilizados no Perl. Se qualquer um destes estiver em utilização
em um script, será necessário corrigir nomes de caminhos ao migrar.

Tabela 3. Comandos comuns de manipulação de caminhos no Perl

Etapa 4: Inspecionar a utilização de variáveis especiais que contêm informações específicas do Solaris

Algumas variáveis especiais contêm informações sobre o ambiente que
poderão ser específicas para o Solaris. Será necessário identificar
essas variáveis e realizar as conversões necessárias.

A Tabela 4
relaciona algumas variáveis principais que pode conter referências ou
informações específicas do Solaris.

Tabela 4. Algumas variáveis Perl principais. Veja todas em Documentação de Programação Perl

Etapa 5: Identificar a utilização de funções que são implementadas de maneira diferente entre plataformas

Algumas funções Perl principais não foram implementadas ou foram
implementadas de maneira diferente em diversas plataformas. Essas
funções se comportarão diferente no Solaris e no Linux.

Será necessário
alterá-las de modo que cooperem ou encontrem a versão complementar da
plataforma Linux e sigam sem interrupção para ela. Novamente, consulte a
Documentação de Programação Perl.

Conclusão

Identificar os cinco componentes mais comuns de scripts Perl que podem
causar problemas ao migrar do Solaris para o Linux (ou HP/UX ou AIX para
Linux) não é muito difícil.

Porém, realizar as correções de código e
substituições de código para trazer seus scripts para o Linux com
sucesso poderá tomar tempo, especialmente se houver muitos scripts para
migrar. Os conselhos e exemplos de correção de código neste artigo
deverão ajudá-lo a começar. Boa sorte!

Recursos

Aprender

• Para uma análise mais detalhada do Perl, consulte a
  Documentação de Programação Perl:
  • Perl específico da Plataforma
  • Implementações de funções principais
  • Variáveis predefinidas
  • Perl Portátil
• Confira CPAN, o repositório de módulo Perl.
• O IBM Redbook “Migração do Solaris para o Linux: Um guia para administradores de sistema”
  é um guia excelente para entender as diferenças entre comandos de
  administração do sistema ao migrar scripts do Solaris para o Linux.
• “Guide to porting from Solaris to
  Linux on x86” pode incluir detalhes essenciais aos seus planos de migração.
• A publicação Red Hat “Moving From Solaris
  to Red Hat Enterprise Linux” também poderá ajudar você a migrar do Solaris para o Red Hat.

***

artigo publicado originalmente no developerWorks Brasil, por Wainer Moschetta e Daniel Barboza

Wainer Moschetta é engenheiro de
software no Linux Technology Center da IBM Brasil onde lidera um projeto
de criação de ferramentas para remediação de código em migrações de
UNIX para Linux. Já trabalhou com teste de device drivers para System X e
testes de aplicações J2EE.

Daniel
Barboza é engenheiro de software no IBM Linux Technology Center no
Brasil onde trabalha na criação de ferramentas de migração, o que inclui
automação de migração e regras para migrar de sistemas operacionais
UNIX para Linux. Sua experiência também inclui programação Eclipse,
programação de dispositivos móveis no System X e mestrado em redes
remotas.