[FUG-BR] Atualização maciça: Dicas

[Joao Rocha Braga Filho]

Eu estou fazendo uma atualização maciça na minha estação de trabalho,
e cometi alguns erros e acertos. Acho que aprendi com os dois. Ela ainda
está em andamento, mas resolvi escrever algumas dicas aqui.

Não vou ensinar a compilar kernel, atualizar ports e os fontes do sistema,
etc, mas vou dar uma sequência para paralelizar muitas das tarefas para
que a atualização maciça seja executada o mais rápido possível.

O roteiro envolve atualização do sistema, compilando na máquina, e dos
pacotes. Eu estou fazendo isto para passar do FreeBSD 6.3-RELENG pro
7.0-RELENG, para o KDE 4.1 e ainda para o XOrg 7.3, e mais muitas outras
atualizações.

Muitas tarefas podem ser paralelizadas, por exemplo, downloads ocupam
mais banda e um pouco de CPU e acesso à disco, e as compilações usam
muita CPU, memória e acesso à disco, mas nada de download. Atualizar o
sistema compilando na máquina faz as duas coisas alternadamente. E por
que não paralelizar?

Começando:

1 ) Pode-se fazer cvsup atualizando os fontes e os ports ao mesmo tempo.
Isto consumirá um pouco CPU, mas muito acesso à Internet e acesso à disco.
Estas duas tarefas podem ser paralelizadas sem problemas.

2.a ) Depois de atualizar os fontes, pode-se começar a compilar o sistema
e o kernel. Eles podem ser em paralelo, creio eu, mas isto pode degradar a
máquina. Usando o comando "nice +20" antes do make pode-se atenuar a
degradação do sistema. Exemplo:

nice +20 make buildworld

2.b) Uma vez que o ports tree esteja atualizado, pode-se começar a fazer os
downloads, mas não se pode compilar ainda, pois a compilação será feita com
o sistema que está instalado na máquina, e não o novo que será instalado.

Neste ponto tem uma decisão séria a ser tomada relativa ao espaço em disco
do sistema de arquivos. Se no /usr/ports/distfiles tiver muitos
arquivos, se eles
forem antigos e desatualizados, e tiver pouco espaço no sistema de arquivos, é
conveniente esvaziar no /usr/ports/distfiles. Mas se a maioria estiver
atualizada,
é desaconselhável esvaziá-lo. É uma decisão entre o que serve dali e o espaço
em disco disponível.

Para fazer o download dos fontes de um programa dos ports, e de todas as suas
dependências, use:

make fetch-recursive

Isto nem sequer descompactará os arquivos, Só fará o download deles.

Pra melhor eficiência, faça de algo grande que você use. Por exemplo, se você
usa o KDE, vá para o diretório do KDE nos ports e faça este comando acima. Se
vai instalar o Firefox, faça no diretório do firefox.

Tem programas que não são instalados pelas depenências de grandes programas,
e até não tem as mesmas dependências, como o portaudit e o screen, portanto
podem ser feitos "make fetch-recursive" deles em paralelo.

2.c) Note: A máquina continuará usável neste tempo, mas ela ficará meio ocupada.

3 ) Uma vez que o kernel e o sistema compilaram, pode-se fazer a atualização do
sistema em si. Neste ponto cabe outra decisão. Espera o "make fetch-recursive"
dos ports terminarem, ou para ele para continuar depois, e fazer a instalação do
sistema agora. Eu voto pela interrução, no início de um arquivo que esteja sendo
baixado, para minimizar os prejuízos. Este arquivo interrompido deverá
ser removido
do /usr/ports/distfiles.

Este é o último ponto de usabiilidade do sistema antes da atualização
estar quase
pronta.

Instale o kernel atualizado (Durante este tempo o download pode continuar.).

4 ) Entre e mono-usuário e faça o "make installworld" e o "mergemaster". Depois
de reboot.

Ao final desta etapa, o sistema estará atualizado, mas os ports nele instalados
não estarão.

5.a ) Pode-se retomar o "make fetch-recursive"

5.b ) Fazer a remoção de todos os ports instalados com "pkg_delete
-a". Isto pode
demorar um pouco, e vai fazer acessos ao disco intensamente.

5.c ) Se julgar que o espaço em disco possa ser insuficiente, pode esvaziar o
diretório /usr/obj, que são os arquivos do sistema compilados para
serem instalados.
Neste ponto não necessita mais deles. A presença deles pode diminuir o tempo
de compilação duma nova atualização do sistema, mas consome um bom espaço
em disco. Esta tarefa pode ser adiada tranquilamente, e a decisão de
fazê-la ou não
ficar dependendo do consumo do espaço em disco.

6.a e b ) Comece a compilar os ports, e continuar com o download. A condição
é que o download esteja adiantado em relação à compilação.

Para impedir um disco cheio, pode fazer um make clean depois de cada final de
compilação dos ports.

De vez em quando olhe como anda a compilação, pois é comum pedidos de
intervenção do operador, para decisões. Por exemplo, o XOrg pergunta quais
drivers de vídeo devem ser compilados.

Compilações podem ser feitas em paralelo, desde que não conflitem, i.e.,
não tentem compilar a mesma dependência ao mesmo tempo. Eu passei
por isto. A sugestão é compilar algo pequeno em paralelo com algo grande,
ou que garantidamente não interfiram, como apache e mysql. Depois de
um tempo, boa parte das dependências estarão compiladas e instaladas,
e as coisas pequenas e médias não conflitarão tanto.


Observações finais:

É comum na compilação de um port a alternância entre download e
compilação. Nesta receita acima não ocorrem estas pausas para download,
pois eles foram feitos antecipadamente. Mas também pode-se antecipar
as descompactações com "make patch" e "make extract". Pena que não
exista um "make extract-recursive" ou um "make patch-recursive".

Parece que existe um modo do processo não parar a cada pedido de
intervenção do usuário e configuração: "make config-recursive".

Se o espaço em disco for pequeno, pode-se usar "make distclean" depois de
cada port pronto, para remover os arquivos não mais necessários que estão
no /usr/ports/distfiles e os temporários da compilação.


Isto virou quase que um artigo. Se alguém quiser colocar em um site, coloque
colocando o meu nome, e me passe o link, e se tiver contribuições, coloque
os nomes de quem contribuiu após o meu.


Abraços a todos,
    João Rocha.


-- 
"Sempre se apanha mais com as menores besteiras. Experiência própria."

goffredo at gmail.com