Note

The Funtoo Linux project has transitioned to "Hobby Mode" and this wiki is now read-only.

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
 
(63 intermediate revisions by 8 users not shown)
Line 1: Line 1:
{{#layout:doc}}{{#widget:AddThis}}[[Metro]] é o build system para os stages Funtoo Linux e [[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
}}
}}
<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>


= Preface =
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.
 
== 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]].
Please see [[{{FULLPAGENAME}}/Initial Setup|Initial Setup]] for instructions on how to get Metro up and running on your system.
 
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]]
}}
 
= Construindo stages do Gentoo =
 
Metro pode também ser construir os stages do Gentoo. Depois de migrar para o profile do Funtoo, veja http://www.funtoo.org/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.
http://www.funtoo.org/Funtoo_Profiles
 
= Advanced Features =
 
Metro also includes a number of advanced features that can be used to automate builds and set up distributed build servers. These features require you to {{c|emerge sqlalchemy}}, as SQLite is used as a dependency.
 
== Repository Management ==
 
Metro includes a script in the {{c|scripts}} directory called {{c|buildrepo}}. Buildrepo serves as the heart of Metro's advanced repository management features.
 
=== Initial Setup ===
 
To use {{c|buildrepo}}, you will first need to create a {{f|.buildbot}} configuration file. Here is the file I use on my 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
}}
 
This file is actually a python source file that defines the tuples {{c|builds}}, {{c|arches}} and {{c|subarches}}. These variables tell {{c|buildrepo}} which builds, arches and subarches it should manage. A {{c|map_build()}} function is also defined which {{c|buildbot}} uses to determine what kind of build to perform. The arguments passed to the function are based on the last successful build. The function can read these arguments and return a string to define the type of the next build. In the above example, the {{c|map_build()}} function will cause the next build after a freshen build to be a full build, and the next build after a full build to be a freshen build, so that the build will alternate between full and freshen.
 
== Automated Builds ==
 
Once the {{c|.buildbot}} file has been created, the {{c|buildrepo}} and {{c|buildbot.sh}} tools are ready to use. Here's how they work. These tools are designed to keep your repository ({{c|path/mirror}} in {{f|/root/.metro}} up-to-date by inspecting your repository and looking for stages that are out-of-date.
 
To list the next build that will be performed, do this -- this is from my 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=''
}}
 
If no output is displayed, then all your builds are up-to-date.
 
To actually run the next build, run {{c|buildbot.sh}}:
 
{{console|body=
# ##i##./buildbot.sh
}}
 
If you're thinking that {{c|buildbot.sh}} would be a good candidate for a cron job, you've got the right idea!
 
=== List Builds ===
 
To get a quick look at our repository, let's run the {{c|buildrepo fails}} command:
 
{{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
}}
 
On my AMD Jaguar build server, on Feb 20, 2015, this lists all the builds that {{c|buildrepo}} has been configured to manage. The first number on each line is a '''failcount''', which is the number of consecutive times that the build has failed. A zero value indicates that everything's okay. The failcount is an important feature of the advanced repository management features. Here are a number of behaviors that are implemented based on failcount:
 
* If {{c|buildbot.sh}} tries to build a stage and the build fails, the failcount is incremented.
* If the build succeeds for a particular build, the failcount is reset to zero.
* Builds with the lowest failcount are prioritized by {{buildrepo}} to build next, to steer towards builds that are more likely to complete successfully.
* Once the failcount reaches 3 for a particular build, it is removed from the 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...
}}
 
== Repository Maintenance ==
 
A couple of repository maintenance tools are provided:
 
* {{c|buildrepo digestgen}} will generate hash files for the archives in your repository, and clean up stale hashes.
* {{c|buildrepo index.xml}} will create an index.xml file at the root of your repository, listing all builds available.
* {{c|buildrepo clean}} will output a shell script that will remove old stages. No more than the three most recent stage builds for each build/arch/subarch are kept.
 
== Distributed Repositories ==
 
In many situation, you will have a number of build servers, and each will build a subset of your master repository, and then upload builds to the master repository. This is an area of Metro that is being actively developed. For now, automated upload functionality is not enabled, but is expected to be implemented in the relatively near future. However, it is possible to have your master repository differentiate between subarches that are built locally, and thus should be part of that system's {{c|buildbot}} build rotation, and those that are stored locally and built remotely. These builds should be cleaned when {{c|buildrepo clean}} is run, but should not enter the local build rotation. To set this up, modify {{f|/root/.buildbot}} and use the {{c|subarches}} and {{c|all_subarches}} variables:
 
{{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]]
__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"