Difference between revisions of "Funtoo:Metro/pt-br"

From Funtoo
Jump to navigation Jump to search
(Updating to match new version of source page)
Tag: Replaced
 
(56 intermediate revisions by 6 users not shown)
Line 1: Line 1:
{{#layout:doc}}{{#widget:AddThis}}[[Metro]] é o build system para os stages Funtoo Linux e [[Pt-br/Gentoo_Linux|Gentoo Linux]]. Ele automatiza o processo de bootstrap.
{{Project
 
|summary=This project is focused on {{c|metro}}, the framework used to create new Funtoo Linux builds.
Esse tutorial te guiará através da instalação, configuração e execução do [[Metro]].
|leads=Drobbins
 
|subpages=Initial Setup, Manual Setup, Concepts and Terminology, Configuring Metro, Recipes, Automation, Data Model
Esses outros documentos do Metro também estão disponíveis:
|translate=yes
 
{{#ask: [[Category:Metro]]
|format=ul
}}
 
= Preface =
 
== Como o Metro Funciona ==
 
Metro é um sistema de construção automática do Funtoo, e é utilizado para construir  os tarballs do Linux stage tarballs.
 
[[Metro]] Não pode gerar um stage tarball vazio. Para gerar um novo stage tarball, o [[Pt-br/Metro|Metro]] precisa utilizar um stage tarball antigo existente chamado de um "seed" stage. Esse seed stage tipicamente é utilizando como o ''ambiente build'' para a criação do stage que queremos.
 
O [[Metro]] pode utilizar dois tipos de seed stages. Tradicionalmente, o [[Pt-br/Metro|Metro]] tem utilizando um stage3 como um seed stage. Esse stage3 é então utilizado para construir um novo stage1, que por sua vez é utilizado para construir um novo stage2, e depois um novo stage3. Esse é geralmente o mais confiável meio de construir [[Gentoo Linux]] ou Funtoo Linux, assim ele é a aproximação recomendada.
{{fancyimportant|'''Depois de carregar o metro builds no Funtoo profile, Gentoo stages não são mais fornecidos'''!}}
 
== Seeds e Build Isolation ==
 
um outro conceito importante a mencionar aqui é algo chamado de ''build isolation''. Porque o [[Pt-br/Metro|Metro]] gera um ambiente build isolado, e o ambiente build é explicitamente definido utilizando entidades tangíveis existentes -- um seed stage e um portage snapshot -- você obterá resultados repetíveis, consistentes. Em outras palavras, A mesma seed stage, portage snapshot e instruções de build gerarão um resultado essencialmente idêntico, mesmo se você desempenhar o build um mês depois na workstation de outra pessoa.
 
== Build Local ==
 
Digamos que você quisesse construir um novo stage3 tarball <tt>pentium4</tt>. O método recomendado de se fazer isso seria agarrar um stage3 tarball <tt>pentium4</tt>  existente para utilizar como seu seed stage. Será dito ao [[Metro]] que utilizr esse stage3 <tt>pentium4</tt> existente para construir um novo stage1 para o mesmo <tt>pentium4</tt>. Para esse processo, o stage3 <tt>pentium4</tt> genérico forneceria o ''build environment'' para a criação de nosso novo stage1. Depois, o novo stage1 serviria como o build environment para a criação de novo stage2 <tt>pentium4</tt>. E o novo stage2 <tt>pentium4</tt> serviria como build environment para a criação do novo stage3 <tt>pentium4</tt>.
 
Na terminologia [[Metro]] isso é chamado de um '''local build''', que significa que um stage3 de uma dada arquitetura é utilizada para semear (seed) um build novinho da mesma arquitetura. Incidentalmente esse será o primeiro exercício  que vamos realizar nesse tutorial.
 
Uma semana depois, você pode querer construir um stage34 tarball <tt>pentium4</tt> novo. Ao invés de iniciar a partir do stage3 <tt>pentium4</tt> original novamente, provavelmente você configuraria o [[Metro]] para utilizar o stage3 <tt>pentium4</tt> mais recentemente construído como a seed. [[Metro]] possui funcionalidade built-in para tornar isso fácil, permitindo facilmente encontrar e rastrear a stage3 seed mais recente disponível.
 
== Build Remoto ==
 
[[Metro]] pode também desempenhar '''remote build''', onde um stage3 de uma arquitetura diferente, mas binariamente compatível, é utilizada como uma seed para construir um stage3 de arquitetura diferente. Consequentemente o segundo exercício que vamos realizar nesse tutorial será construir um stage3 tarball <tt>core2 32bit</tt> a partir do stage3 tarball do <tt>pentium4</tt> que acabamos de construir.
 
TODO: adicione ressalvas a respeito de qual archs podem ser semeadas e qual não pode (talvez uma tabela?)
 
== Build Adaptado ==
 
Por ultimo, de nada também vale a pena que ambos <tt>local</tt> e <tt>remote builds</tt>, [[Metro]] pode ser configurado para adicionar e/ou remover pacotes individuais ao tarball final.
Vamos dizer que você não possa viver sem <tt>app-misc/screen</tt>, no final desse tutorial, nós mostraremos como ter seu stage3 adaptado para incluí-lo.
 
== Instalando o Metro ==
 
'''O método recomendado e que possui suporte''' é utilizar o Git repository do [[Metro]]. 
 
Certifique-se de que o {{Package|dev-vcs/git}} e o {{Package|dev-python/boto}} (opcional; necessário para suporte EC2) estejam instalados no seu sistema:
 
<console>
# ##i##emerge dev-vcs/git
# ##i##emerge dev-python/boto
</console>
 
Depois, clone o master git repository como a seguir:
 
<console>
# ##i##cd /root
# ##i##git clone git://github.com/funtoo/metro.git
# ##i##cp /root/metro/metro.conf ~/.metro
</console>
 
Você agora terá um diretório chamado <tt>/root/metro</tt> que contem todo o código fonte do [[Metro]].
 
O Metro está agora instalado. É hora de personalizá-lo para seu sistema local.
 
= Configurando o Metro =
 
{{Note|Metro não é atualmente capaz de construir Gentoo stages. Veja {{Bug|FL-901}}.}}
 
[[User:Drobbins|Daniel Robbins]] mantem [[Metro]], então ele vem pre-configurado para com sucesso construir releases (lançamentos) do Funtoo Linux. Antes de ler mais adiantes, você pode querer personalizar algumas configurações básicas como o número de serviços atuais para encaixar suas compatibilidades de hardware ou o diretório  se utilizar para produzir arquivos stage. Isso This is realizado ao editar <tt>~/.metro</tt> que é o o arquivo de configuração mestre do [[Metro]].
 
Note que <code>path/install</code> deve apontar para aonde o metro foi instalado. Aponte <code>path/distfiles</code> para aonde seus distfiles residem. Também defina <code>path/mirror/owner</code> e <code>path/mirror/group</code> ao proprietário e grupo de todos os arquivos que serão escritos ao diretório do repositório build, que por padrão (como pelo arquivo de configuração) está em <code>/home/mirror/funtoo</code>. O diretório cache normalmente reside dentro do diretório temp -- Isso pode ser modificado como desejado. O diretório cache pode acabar mantendo muitos pacotes .tbz2 em cache, e consumir um monte do storage. Você pode querer alocar o diretório temp em mais rápidos, para obter tempos de compilação mais rápido, e alocar o diretório cache en storage mais lento, porém mais abundante.
 
{{file|name=.metro|desc=Metro configuration|body=
# Main metro configuration file - these settings need to be tailored to your install:
 
[section path]
install: /root/metro
tmp: /var/tmp/metro
cache: $[path/tmp]/cache
distfiles: /var/src/distfiles
work: $[path/tmp]/work/$[target/build]/$[target/name]
 
[section path/mirror]
 
: /home/mirror/funtoo
owner: root
group: repomgr
dirmode: 775
 
[section portage]
 
MAKEOPTS: auto
 
[section emerge]
 
options: --jobs=4 --load-average=4 --keep-going=n
 
# This line should not be modified:
[collect $[path/install]/etc/master.conf]
}}
 
== Arch e Subarch ==
 
No exemplo a seguir, estamos gerando um stage3 pentium4 compilado para compatibilidade binária x86-32bit. Pentium4 é uma subarch da arquitetura x86-32bit. Uma vez que você tenha metro instalado você pode encontrar uma lista completa de cada subarch em seu diretório <tt>/root/metro/subarch</tt>; cada subarch terá a extensão de arquivo .spec
Example:
<console>
###i## ls /root/metro/subarch
# ls subarch/
amd64-bulldozer-pure64.spec  armv7a.spec          core-avx-i.spec        i686.spec        pentium.spec
amd64-bulldozer.spec        armv7a_hardfp.spec  core2_32.spec          k6-2.spec        pentium2.spec
amd64-k10-pure64.spec        athlon-4.spec        core2_64-pure64.spec    k6-3.spec        pentium3.spec
amd64-k10.spec              athlon-mp.spec      core2_64.spec          k6.spec          pentium4.spec
amd64-k8+sse3.spec          athlon-tbird.spec    corei7-pure64.spec      native_32.spec    pentiumpro.spec
amd64-k8+sse3_32.spec        athlon-xp.spec      corei7.spec            native_64.spec    prescott.spec
amd64-k8-pure64.spec        athlon.spec          generic_32.spec        niagara.spec      ultrasparc.spec
amd64-k8.spec                atom_32.spec        generic_64-pure64.spec  niagara2.spec    ultrasparc3.spec
amd64-k8_32.spec            atom_64-pure64.spec  generic_64.spec        nocona.spec      xen-pentium4+sse3.spec
armv5te.spec                atom_64.spec        generic_sparcv9.spec    opteron_64.spec  xen-pentium4+sse3_64.spec
armv6j.spec                  btver1.spec          geode.spec              pentium-m.spec
armv6j_hardfp.spec          btver1_64.spec      i486.spec              pentium-mmx.spec
</console>
 
= Primeiras contruções de stages  (local build) =
 
Para começar tudo isso, precisamos inicializar o processo ao baixar uma semente stage3 inicial para utilizar para a construção e alocá-la em seu local apropriado em <tt>/home/mirror/funtoo</tt>, então assim [[Metro]] pode encontrá-la. Também precisaremos criar alguns &quot;controles&quot especiais; arquivos em <tt>/home/mirror/funtoo</tt>, que permitirão ao [[Metro]] entender como ele deve se proceder.
 
== Primeiro Passo: Definir repositório pentium4 (build local) ==
 
Assumindo que estamos segundo os passos básicos esboçados na seção anterior, e construindo um funtoo instável (<tt>funtoo-current</tt>) construído para o <tt>pentium4</tt>, utilizando um stage3 <tt>pentium4</tt> genérico como uma semente stage, então aqui o primeiro conjunto de passos que desempenharemos:
 
<console>
# ##i##install -d /home/mirror/funtoo/funtoo-current/x86-32bit/pentium4
# ##i##install -d /home/mirror/funtoo/funtoo-current/snapshots
# ##i##cd /home/metro/mirror/funtoo/funtoo-current/x86-32bit/pentium4
# ##i##install -d 2011-12-13
# ##i##cd 2011-12-13
# ##i##wget -c http://ftp.osuosl.org/pub/funtoo/funtoo-current/x86-32bit/pentium4/2011-12-13/stage3-pentium4-funtoo-current-2011-12-13.tar.xz
# ##i##cd ..
# ##i##install -d .control/version
# ##i##echo "2011-12-13" > .control/version/stage3
# ##i##install -d .control/strategy
# ##i##echo local >  .control/strategy/build
# ##i##echo stage3 > .control/strategy/seed
</console>
 
OK, vamos rever os passos acima. Primeiro, criamos o diretório <tt>/home/mirror/funtoo/funtoo-current/x86-32bit/pentium4</tt>, ao qual é aonde Metro esperará encontrar builds pentium4  instáveis <tt>funtoo-current</tt>  -- ele é configurado para procurar aqui por padrão. depois criamos um diretório especialmente nomeado para abrigar nossa semente x86 stage3. De novo, por padrão, Metro espera que o diretório seja nomeado desse jeito. Entramos nesse diretório, e baixamos nossa semente x86 stage3 a partir do funtoo.org. Note que o selo da versão <tt>2010-12-24</tt> corresponde. Certifique-se de que o nome do seu diretório corresponde com o nome do stage3 também. Tudo tem sido configurado para corresponder com o layout de sistema de arquivo padrão do Metro.
 
Depois, voltamos ao dirtório<tt>/home/mirror/metro/funtoo-current/x86-32bit/pentium4</tt>, e dentro dele, geramos um diretório <tt>.control</tt>. Esse diretório e seus subdiretórios contem arquivos especiais que o Metro refere para determinar certo aspectos de seu comportamento. O arquivo <tt>.control/version/stage3</tt> é utilizado pelo Metro para rastrear o stage3 construído mais recentemente para essa build e subarch particular. Metro automaticamente atualizará esse arquivo com um novo selo de versão depois que ele constrói com sucesso um novo stage3. Mas por rasão que Metro não ''construiu'' na verdade esse stage3, precisamos definir o arquivo <tt>.control/version/stage3</tt> manualmente. Isso permite ao Metro encontrar nosso stage3 baixado quando definimos nosso build pentium4 build a se utilizar como uma seed. Note também que o Metro gerará um arquivo <tt>.control/version/stage1</tt> similar depois que ele construir com sucesso um stage1 funtoo-current para pentium4.
 
Definimos também os arquivos <tt>.control/strategy/build</tt> e <tt>.control/strategy/seed</tt> com valores de <tt>local</tt> e <tt>stage3</tt> respectivamente. Esses arquivos definem a estratégia de construção que Metro utilizará quando nós construirmos stages funtoo-current para pentium4. Com uma estratégia de construção de <tt>local</tt>, Metro gerará raíz de sia seed stage a partir do funtoo-current pentium4, o diretório atual. E com uma estratégia de seed de <tt>stage3</tt>, Metro utilizará um stage3 como uma seed, e utilizará essa seed para construir um novo stage1, stage2 e stage3.
 
== Segundo Passo: Construindo os stages para pentium4 ==
 
Incidentalmente, se tudo o que você queria fazer nesse ponto era construir um novo stage1/2/3 do funtoo-current para pentium4 (mais o openvz e vserver templates). Você começaria o processo ao digitar:
 
<console>
# ##i##cd /root/metro
# ##i##scripts/ezbuild.sh funtoo-current pentium4
</console>
 
Se tiver uma máquina lenta, isso poderia levar várias horas para ser completada por que vários componentes "pesados" como gcc ou glibc tem que ser compilados em cada stage. Uma vêz que um stage tem sido completado com sucesso, ele é alocado no subdiretório <tt>"${METRO_MIRROR}/funtoo-current/x32-bit/pentium4/YYYY-MM-DD"</tt>, onde <tt>YYYY-MM-DD</tt> é a data de hoje no horário que o script <tt>ezbuild.sh</tt> foi iniciado ou a data que você inseriu na linha de comando ezscript.sh.
 
= Construir para outra arquitetura compatível binária (remote build) =
 
Como escrito acima, [[Metro]] é capaz de desenvolver '''remote build''' construindo stage3 para arquitetura disferente a partir de uma seeding stage3 binária compatível (ex. utilizando um stage3 para pentium4 para semear um stage3 para <tt>Intel Core2 32bits</tt>).
 
Na terminologia Metro Isso é chamado de uma '''remote build''' (um stage 3 de uma arquitetura diferente, mas binariamente compatível, é utilizada como uma semente).
Qual não é compatível? Você não pode utilizar uma arquitetura <tt>Sparc</tt> para gerar um stage baseado em <tt>x86</tt> ou <tt>ARM</tt> e vice-versa. Se você utilizar um stage para 32bit então você não quer semear uma build 64bit a partir dessa. Certifique-se de que você está utilizando um stage a partir da mesma arquitetura que você está tentando semear. Verifique [http://ftp.osuosl.org/pub/funtoo/funtoo-current/ Funtoo-current FTP Mirror] para um stage que é da mesma Arquitetura que você estará construindo. 
 
{{Note|Com frequência, uma build (ex. funtoo-current) pode ser utilizada como uma seed (semente) para outra build como funtoo-stable. No entanto, hardened builds requerem hardened stages como seeds a fim de que a build finalize com sucesso.}}
 
== Primeiro Passo: Definir o repositório Core_2 32bit ==
 
Nesse exemplo, vamos utilizar esse stage3 funtoo-current para pentium4 para semear um novo stage3 funtoo-current build para Core_2 32bit. Para conseguir fazer isso, precisamos definir o diretório pentium4 build como a seguir:
 
<console>
# ##i## cd /home/mirror/funtoo/funtoo-current/x86-32bit
# ##i##install -d core2_32
# ##i##cd core2_32
# ##i##install -d .control/strategy
# ##i##echo remote > .control/strategy/build
# ##i##echo stage3 > .control/strategy/seed
# ##i##install -d .control/remote
# ##i##echo funtoo-current > .control/remote/build
# ##i##echo x86-32bit > .control/remote/arch_desc
# ##i##echo pentium4 > .control/remote/subarch
</console>
 
Os passos que seguimos são similares aqueles que realizamos para um ''local build'' para definir nosso diretório pentium4 directory para local build. However, note the differences. We didn't download a stage, because we are going to use the pentium4 stage to build a new Core_2 32bit stage. Também não geramos os arquivos <tt>.control/version/stage{1,3}</tt>  por que o Metro os gerará para nós depois que ele construir com sucesso um novo stage1 e stage3. Ainda estamos utilizando uma seed strategy <tt>stage3</tt>, mas definimos a build strategy para <tt>remote</tt>, que significa que vamos utilizar uma seed stage que não é desse subdiretório particular. de onde vamos conseguir obtê-lo? O diretório <tt>.control/remote</tt> contem essa informação, e deixa o Metro saber que ele deve procurar seu seed stage3 dentro do diretório <tt>/home/mirror/funtoo/funtoo-current/x86-32bit/pentium4</tt>. Qual ele obterá? Você imaginou isso -- o ''stage3'' mais recente construído (desde nossa seed strategy foi definido <tt>stage3</tt>) que contem a version stamp de <tt>2010-12-24</tt>, como gravado em <tt>/home/mirror/funtoo-current/x86-32bit/pentium4/.control/version/stage</tt>. Agora você oide você como todas esses arquivos de controle se juntam para direcionar o Metro a fazer a coisa correta.
 
{{Note|<code>arch_desc</code> deve ser definido para uma das: <code>x86-32bit</code>, <code>x86-64bit</code> ou <code>pure64</code> para sistemas compatíveis com PC. Você deve utilizar uma build de 32-bit como uma seed para outras builds de 32-bit, e uma build de 64-bit como uma seed para outras buidls de 64-bit.}}
 
== Segundo Passo: Construir os stages para Core_2 32bit stages ==
 
Agora, você poderia começar a construir seunovo stage1/2/3 para Core_2 32bit stage1/2/3 (incluindo openvz e vserver templates) ao digitar o seguinte:
 
<console>
# ##i##/root/metro/scripts/ezbuild.sh funtoo-current core2_32
</console>
 
Nesse caso, os stages gerados no subdiretório <tt>/home/mirror/funtoo/funtoo-current/x32-bit/core2_32/YYYY-MM-DD</tt> subdirectory.
 
== Terceiro Passo: O Próximo Build ==
 
nesse ponto, você tem agora um novo stage3 para Core_2 32bit stage3, construído utilizando um stage3 "remote" para pentium4. Uma vez que o remote build é finalizado com sucesso, Metro automaticamente alterará <code>.control/strategy/build</code> para ser <code>local</code> ao invés de <code>remote</code>, assim ele passará a utilizar o stage3 para Core_32bit construído mais recentemente como um seed para quaisquer builds Core_2 32bit a partir de agora.
 
= Construa seu próprio stage3 adaptado =
 
Metro pode ser facilmente configurado para construir stages3 personalizado ao incluir pacotes adicionais. Edite o seguinte arquivo de configuração <tt>/root/metro/etc/builds/funtoo-current/build.conf</tt>:
{{file|name=funtoo-current/build.conf|body=
[collect ../../fslayouts/funtoo/layout.conf]
 
[section release]
 
author: Daniel Robbins <drobbins@funtoo.org>
 
[section target]
 
compression: xz
 
[section portage]
 
FEATURES:
SYNC: $[snapshot/source/remote]
USE:
 
[section profile]
 
format: new
path: gentoo:funtoo/1.0/linux-gnu
arch: $[:path]/arch/$[target/arch_desc]
build: $[:path]/build/current
flavor: $[:path]/flavor/core
mix-ins:
 
[section version]
 
python: 2.7
 
[section emerge]
 
 
[section snapshot]
 
type: live
compression: xz
 
[section snapshot/source]
 
type: git
branch: funtoo.org
# branch to have checked out for tarball:
branch/tar: origin/master
name: ports-2012
remote: git://github.com/funtoo/ports-2012.git
options: pull
 
[section metro]
 
options:
options/stage: cache/package
target: gentoo
 
[section baselayout]
 
services: sshd
 
[section multi]
 
snapshot: snapshot
 
[section files]
 
motd/trailer: [
 
>>> Send suggestions, improvements, bug reports relating to...
 
>>> This release:                  $[release/author]
>>> Funtoo Linux (general):        Funtoo Linux (http://www.funtoo.org)
>>> Gentoo Linux (general):        Gentoo Linux (http://www.gentoo.org)
]
 
[collect ../../multi-targets/$[multi/mode:zap]]
}}
}}
<div class="mw-translate-fuzzy">
{{#layout:doc}}{{#widget:AddThis}}[[Metro]] é o sistema de compilação dos stages para Funtoo Linux e [[Gentoo Linux]]. Ele automatiza o processo de bootstrapping.
</div>


= Construindo stages do Gentoo =
Metro is the tool used by Funtoo Linux to build new releases of Funtoo Linux. It is also available to the public and can be used to build custom versions of Funtoo Linux, or used by developers to perform build testing. This page documents how to install, configure and use Metro. Also note that there is various additional supplemental documentation available on sub-pages, with links above.


Metro pode também ser construir os stages do Gentoo. Depois de migrar para o profile do Funtoo, veja http://www.funtoo.org/Pt-br/Funtoo_Profiles o Metro requisita passos adicionais para isso. Possuímos um open bug para isso -- isso é simplesmente devido ao fato de que focamos em asegurar que o Funtoo Linux construa e construir Gentoo é prioridade mais baixa. Nota historica: Funtoo Linux originalmente iniciou como um fork do Gentoo Linux, assim o metro podia confiavelmente construir os stages do Gentoo.
Please see [[{{FULLPAGENAME}}/Initial Setup|Initial Setup]] for instructions on how to get Metro up and running on your system.
http://www.funtoo.org/Pt-br/Funtoo_Profiles
 
= Recursos Avançados =
 
Metro também inclui um número de recursos avançados que pode ser utilizados automatizar builds e configurar distributed build servers. Esses recursos exigem que você {{c|emerge sqlalchemy}}, como SQLite é utilizado como uma dependência.
 
== Gerenciamento de Repositório ==
 
Metro inclui um script no diretório {{c|scripts}} chamado {{c|buildrepo}}. Buildrepo serve como o coração dos recursos avançados do gerenciamento de repositório do Metro.
 
=== Configuração Inicial ===
 
Para utilizar {{c|buildrepo}}, você primeiro precisará gerar um arquivo de configuração {{f|.buildbot}}. Aqui está o arquivo que eu utilizo no meu AMD Jaguar build server:
 
{{file|name=/root/.buildbot|lang=python|body=
builds = (
"funtoo-current",
"funtoo-current-hardened",
"funtoo-stable",
)
 
arches = (
"x86-64bit",
"pure64"
)
 
subarches = (
"amd64-jaguar",
"amd64-jaguar-pure64",
)
 
def map_build(build, subarch, full, full_date):
# arguments refer to last build...
if full == True:
buildtype =  ( "freshen", )
else:
buildtype =  ("full", )
return buildtype
}}
 
Esse arquivo é na verdade um arquivo de código fonte python que define os tuples {{c|builds}}, {{c|arches}} e {{c|subarches}}. Essas variáveis dizem ao {{c|buildrepo}} quais builds, arches e subarches ele deve gerenciar. Uma função {{c|map_build()}} é também definida a qual {{c|buildbot}} utiliza para determinar que tipo de build realizar. Os argumentos passado para a função são baseadas na ultimo build bem sucedido. A função pode ler esses argumentos e retornar uma string para definir o tipo da próxima build. No exemplo acima, a função {{c|map_build()}} causará a próxima build depois de uma build novinha ser uma build completa, e a próxima build depois de uma build completa se tornar uma nova build, assim a build alternará entre full (completa) e nova (freshen).
 
== Builds Automatizadas ==
 
Uma vêz que o arquivo {{c|.buildbot}} tem sido gerado, as ferramentas {{c|buildrepo}} e {{c|buildbot.sh}} estão prontas para uso. Aqui está como elas funcionam. Essas ferramentas são desenvolvidas para manter seu repositório ({{c|path/mirror}} em {{f|/root/.metro}} atualizados ao inspecionar seu repositório e procurar por stages que estão desatualizados.
 
Para listar a próxima que serão desenvolvidas, faço isso -- Esse vem do meu ARM build server:
 
{{console|body=
# ##i##./buildrepo nextbuild
build=funtoo-current
arch_desc=arm-32bit
subarch=armv7a_hardfp
fulldate=2015-02-08
nextdate=2015-02-20
failcount=0
target=full
extras=''
}}
 
Se nenhuma saída for exibida, então todos as suas builds estão atualizadas.
 
Para na verdade executar a próxima build, execute {{c|buildbot.sh}}:
 
{{console|body=
# ##i##./buildbot.sh
}}
 
Se você está pensando que {{c|buildbot.sh}} seria uma boa candidata para um cron job, você teve a ideia certa!
 
=== Listar Builds ===
 
Para dar uma rápida olhada em nosso repositório, vamos executar o comando {{c|buildrepo fails}}:
 
{{console|body=
# ##i##./buildrepo fails
  0  2015-02-18 /home/mirror/funtoo/funtoo-current/x86-64bit/amd64-jaguar
  0  2015-02-18 /home/mirror/funtoo/funtoo-current/pure64/amd64-jaguar-pure64
  0  2015-02-18 /home/mirror/funtoo/funtoo-current-hardened/x86-64bit/amd64-jaguar
  0  2015-02-18 /home/mirror/funtoo/funtoo-current-hardened/pure64/amd64-jaguar-pure64
  0  2015-02-18 /home/mirror/funtoo/funtoo-stable/x86-64bit/amd64-jaguar
  0  2015-02-18 /home/mirror/funtoo/funtoo-stable/pure64/amd64-jaguar-pure64
}}
 
Em meu AMD Jaguar build server, em 20 de Fevereiro de 2015, Isso lista todos os builds que {{c|buildrepo}} foi configurado para gerenciar. O primeiro número em cada linha é uma '''failcount''', a qual é o numero de números consecutivos que a build falhou. Um valor zero indica que tudo está okay. A failcount é um recurso importante dos recursos avançados de gerenciamento de repositório (advanced repository management features). Aqui estão um número de comportamentos que são implementados baseado na failcount:
 
* If {{c|buildbot.sh}} tenta construir um stage e a build falha, a failcount é incrementada.
* Se a build obtiver êxito para uma build particular, a failcount e redefinida para zero.
* Constrói com a failcount mais baixa são priorizadas por {{buildrepo}} para construir a próxima, para orientar as builds que são mais provavelmente completas com sucesso.
* Uma vez que a failcount alcança 3 para uma build particular, ele é removido da build rotation.
 
=== Resetting Failcount ===
 
If a build has issues, the failcount for a build will reach 3, at which point it will be pulled out of build rotation. To clear failcount, so that these builds are attempted again -- possibly fixed by new updates to the Portage tree -- use {{c|buildrepo zap}}:
 
{{console|body=
# /root/metro/scripts/buildrepo zap
Removing /mnt/data/funtoo/funtoo-current/arm-32bit/armv7a_hardfp/.control/.failcount...
Removing /mnt/data/funtoo/funtoo-current/arm-32bit/armv6j_hardfp/.control/.failcount...
Removing /mnt/data/funtoo/funtoo-current/arm-32bit/armv5te/.control/.failcount...
}}
 
== Manutenção (Maintenance) do Repositório ==
 
Uma dupla de ferramentas de manutenção do repositório são fornecidas:
 
* {{c|buildrepo digestgen}} gerará arquivos hash para os arquivos em seu repositório, e limpará os hashes velhos.
* {{c|buildrepo index.xml}} gerará um arquivo index.xml no root do seu repositório, listando todos os builds disponíveis.
* {{c|buildrepo clean}} exibirá a saída shell script que removerá stages antigos. Nada mais que os três stage builds mais recentes para cada build/arch/subarch são mantidos.
 
== Repositórios Distribuídos ==
 
Em muitas situações, você terá um número de build servers, e cada um construirá um sub-conjunto de seu master repository, e depois realizará upload builds para o master repository. Essa é uma área do Metro que está sendo ativamente desenvolvida. Por hora, funcionalidade automatizada de upload não está habilitada, mas é esperada ser implementada em um futuro relativamente próximo. No entanto, é possível ter seu master repository diferenciado entre subarches que são localmente construídos, e assim devem ser parte daquela build rotation {{c|buildbot}} do sistema, e aquelas que são armazenadas localmente e construídas remotamente. Esses builds devem ser limpos quando {{c|buildrepo clean}} for executados, mas não deve entrar na rotação build local (local build rotation). Para configurar isso, modifique {{f|/root/.buildbot}} e utilize as variáveis {{c|subarches}} e {{c|all_subarches}}:
 
{{file|name=/root/.metro|desc=Excerpt of .metro config for master repository|body=
# subarches we are building locally:
 
subarches = (
        "pentium4",
        "athlon-xp",
        "corei7",
        "corei7-pure64",
        "generic_32",
        "i686",
        "amd64-k8",
        "amd64-k8-pure64",
        "core2_64",
        "core2_64-pure64",
        "generic_64",
        "generic_64-pure64",
)
 
# Things we need to clean, even if we may not be building:
 
all_subarches = subarches + (
        "atom_32",
        "atom_64",
        "atom_64-pure64",
        "amd64-k10",
        "amd64-k10-pure64",
        "amd64-bulldozer",
        "amd64-bulldozer-pure64",
        "amd64-steamroller",
        "amd64-steamroller-pure64",
        "amd64-piledriver",
        "amd64-piledriver-pure64",
        "amd64-jaguar",
        "amd64-jaguar-pure64",
        "intel64-haswell",
        "intel64-haswell-pure64",
        "intel64-ivybridge-pure64",
        "intel64-ivybridge",
        "armv7a_hardfp",
        "armv6j_hardfp",
        "armv5te"
)
}}


[[Category:HOWTO]]
[[Category:HOWTO]]
[[Category:Metro]]
[[Category:Metro]]
[[Category:pt_BR]]
__TOC__


__TOC__
[[Category:Official Documentation]]
{{ProjectFooter}}

Latest revision as of 01:38, October 11, 2022

Other languages:
English • ‎Türkçe • ‎português do Brasil • ‎日本語
   Summary
This project is focused on metro, the framework used to create new Funtoo Linux builds.
   Subpages
   People
Leads

Warning: Display title "Funtoo Metro/pt-br Project" overrides earlier display title "Metro".

{{#layout:doc}}Metro é o sistema de compilação dos stages para Funtoo Linux e Gentoo Linux. Ele automatiza o processo de bootstrapping.

Metro is the tool used by Funtoo Linux to build new releases of Funtoo Linux. It is also available to the public and can be used to build custom versions of Funtoo Linux, or used by developers to perform build testing. This page documents how to install, configure and use Metro. Also note that there is various additional supplemental documentation available on sub-pages, with links above.

Please see Initial Setup for instructions on how to get Metro up and running on your system.

Retrieved from "https://www.funtoo.org/index.php?title=Funtoo:Metro/pt-br&oldid=42409"