Difference between revisions of "Pt-br/Metro"

(Seeds and Build Isolation)
 
(21 intermediate revisions by the same user 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.
+
{{#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.
  
 
Esse tutorial te guiará através da instalação, configuração e execução do [[Metro]].
 
Esse tutorial te guiará através da instalação, configuração e execução do [[Metro]].
Line 24: Line 24:
 
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.
 
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.
  
== Local Build ==  
+
== Build Local ==  
  
Say you wanted to build a new <tt>pentium4</tt> stage3 tarball. The recommended method of doing this would be to grab an existing <tt>pentium4</tt> stage3 tarball to use as your seed stage. [[Metro]] will be told to use this existing <tt>pentium4</tt> stage3 to build a new stage1 for the same <tt>pentium4</tt>. For this process, the generic <tt>pentium4</tt> stage3 would provide the ''build environment'' for creating our new stage1. Then, the new stage1 would serve as the build environment for creating the new <tt>pentium4</tt> stage2. And the new <tt>pentium4</tt> stage2 would serve as the build environment for creating the new <tt>pentium4</tt> stage3.
+
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>.
  
In the [[Metro]] terminology this is called a '''local build''', which means a stage3 of a given architecture is used to seed a brand new build of the same architecture. Incidentally this will be the first exercise we are going to perform in this tutorial.
+
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.
  
A week later, you may want to build a brand new <tt>pentium4</tt> stage3 tarball. Rather than starting from the original <tt>pentium4</tt> stage3 again, you'd probably configure [[Metro]] to use the most-recently-built <tt>pentium4</tt> stage3 as the seed. [[Metro]] has built-in functionality to make this easy, allowing it to easily find and track the most recent stage3 seed available.
+
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.
  
== Remote Build ==  
+
== Build Remoto ==  
  
[[Metro]] can also perform '''remote build''', where a stage3 of a different, but binary compatible, architecture is used as a seed to build a different architecture stage3. Consequentiality the second exercise we are going to perform in this tutorial will be to build a <tt>core2 32bit</tt> stage3 tarball from the <tt>pentium4</tt> stage3 tarball we have just built.
+
[[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: add caveats about what archs can be seeded and what can be not (maybe a table?)
+
TODO: adicione ressalvas a respeito de qual archs podem ser semeadas e qual não pode (talvez uma tabela?)
  
== Tailored Build ==  
+
== Build Adaptado ==  
  
Last, it's also worthy noting that both in <tt>local</tt> and <tt>remote builds</tt>, [[Metro]] can be configured to add and/or remove individual packages to the final tarball.
+
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.
Let's say you can't live without <tt>app-misc/screen</tt>, at the end of this tutorial, we will show how to have your tailored stage3 to include it.
+
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.
  
== Installing Metro ==
+
== Instalando o Metro ==
  
'''The recommended and supported method''' is to use the Git repository of [[Metro]].   
+
'''O método recomendado e que possui suporte''' é utilizar o Git repository do [[Metro]].   
  
Ensure that {{Package|dev-vcs/git}} and {{Package|dev-python/boto}} (optional; required for EC2 support) are installed on your system:
+
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>
 
<console>
Line 54: Line 54:
 
</console>
 
</console>
  
Next, clone the master git repository as follows:
+
Depois, clone o master git repository como a seguir:
  
 
<console>
 
<console>
Line 62: Line 62:
 
</console>
 
</console>
  
You will now have a directory called <tt>/root/metro</tt> that contains all the [[Metro]] source code.
+
Você agora terá um diretório chamado <tt>/root/metro</tt> que contem todo o código fonte do [[Metro]].
  
Metro is now installed. It's time to customize it for your local system.
+
O Metro está agora instalado. É hora de personalizá-lo para seu sistema local.
  
= Configuring Metro =
+
= Configurando o Metro =
  
{{Note|Metro is not currently able to build Gentoo stages. See {{Bug|FL-901}}.}}
+
{{Note|Metro não é atualmente capaz de construir Gentoo stages. Veja {{Bug|FL-901}}.}}
  
[[User:Drobbins|Daniel Robbins]] maintains [[Metro]], so it comes pre-configured to successfully build Funtoo Linux releases. Before reading further, you might want to customize some basic settings like the number of concurrent jobs to fit your hardware's capabilities or the directory to use for produced stage archives. This is accomplished by editing <tt>~/.metro</tt> which is the [[Metro]]'s master configuration file.
+
[[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 note that <code>path/install</code> must point to where metro was installed. Point <code>path/distfiles</code> to where your distfiles reside. Also set <code>path/mirror/owner</code> and <code>path/mirror/group</code> to the owner and group of all the files that will be written to the build repository directory, which by default (as per the configuration file) is at <code>/home/mirror/funtoo</code>. The cache directory normally resides inside the temp directory -- this can be modified as desired. The cache directory can end up holding many cached .tbz2 packages, and eat up a lot of storage. You may want to place the temp directory on faster storage, for faster compile times, and place the cache directory on slower, but more plentiful storage.
+
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=
 
{{file|name=.metro|desc=Metro configuration|body=
Line 103: Line 103:
 
}}
 
}}
  
== Arch and Subarch ==
+
== Arch e Subarch ==
  
In the following example we are creating a pentium4 stage 3 compiled for x86-32bit binary compatibility. Pentium4 is a subarch of the x86-32bit architecture. Once you have metro installed you may find a full list of each subarch in your <tt>/root/metro/subarch</tt> directory each subarch will have the file extension .spec
+
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:
 
Example:
 
<console>
 
<console>
Line 124: Line 124:
 
</console>
 
</console>
  
= First stages build (local build) =
+
= Primeiras contruções de stages (local build) =
  
To get this all started, we need to bootstrap the process by downloading an initial seed stage3 to use for building and place it in its proper location in <tt>/home/mirror/funtoo</tt>, so that [[Metro]] can find it. We will also need to create some special &quot;control&quot; files in <tt>/home/mirror/funtoo</tt>, which will allow [[Metro]] to understand how it is supposed to proceed.
+
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.
  
== Step 1: Set up pentium4 repository (local build) ==
+
== Primeiro Passo: Definir repositório pentium4 (build local) ==
  
Assuming we're following the basic steps outlined in the previous section, and building an unstable funtoo (<tt>funtoo-current</tt>) build for the <tt>pentium4</tt>, using a generic <tt>pentium4</tt> stage3 as a seed stage, then here the first set of steps we'd perform:
+
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>
 
<console>
Line 147: Line 147:
 
</console>
 
</console>
  
OK, let's review the steps above. First, we create the directory <tt>/home/mirror/funtoo/funtoo-current/x86-32bit/pentium4</tt>, which is where Metro will expect to find unstable <tt>funtoo-current</tt> pentium4 builds -- it is configured to look here by default. Then we create a specially-named directory to house our seed x86 stage3. Again, by default, Metro expects the directory to be named this way. We enter this directory, and download our seed x86 stage3 from funtoo.org. Note that the <tt>2010-12-24</tt> version stamp matches. Make sure that your directory name matches the stage3 name too. Everything has been set up to match Metro's default filesystem layout.
+
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.
  
Next, we go back to the <tt>/home/mirror/metro/funtoo-current/x86-32bit/pentium4</tt> directory, and inside it, we create a <tt>.control</tt> directory. This directory and its subdirectories contain special files that Metro references to determine certain aspects of its behavior. The <tt>.control/version/stage3</tt> file is used by Metro to track the most recently-built stage3 for this particular build and subarch. Metro will automatically update this file with a new version stamp after it successfully builds a new stage3. But because Metro didn't actually ''build'' this stage3, we need to set up the <tt>.control/version/stage3</tt> file manually. This will allow Metro to find our downloaded stage3 when we set up our pentium4 build to use it as a seed. Also note that Metro will create a similar <tt>.control/version/stage1</tt> file after it successfully builds an pentium4 funtoo-current stage1.
+
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.
  
We also set up <tt>.control/strategy/build</tt> and <tt>.control/strategy/seed</tt> files with values of <tt>local</tt> and <tt>stage3</tt> respectively. These files define the building strategy Metro will use when we build pentium4 funtoo-current stages. With a build strategy of <tt>local</tt>, Metro will source its seed stage from funtoo-current pentium4, the current directory. And with a seed strategy of <tt>stage3</tt>, Metro will use a stage3 as a seed, and use this seed to build a new stage1, stage2 and stage3.
+
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.
  
== Step 2: Building the pentium4 stages ==
+
== Segundo Passo: Construindo os stages para pentium4 ==
  
Incidentally, if all you wanted to do at this point was to build a new pentium4 funtoo-current stage1/2/3 (plus openvz and vserver templates). You would begin the process by typing:
+
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>
 
<console>
Line 162: Line 162:
 
</console>
 
</console>
  
If you have a slow machine, it could take several hours to be completed because several "heavy" components like gcc or glibc have to be recompiled in each stage. Once a stage has been successfully completed, it is placed in the <tt>"${METRO_MIRROR}/funtoo-current/x32-bit/pentium4/YYYY-MM-DD"</tt> subdirectory, where <tt>YYYY-MM-DD</tt> is today's date at the time the <tt>ezbuild.sh</tt> script was started or the date you put on the ezscript.sh command line.
+
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.
  
= Building for another binary compatible architecture (remote build) =
+
= Construir para outra arquitetura compatível binária (remote build) =
  
As written above, [[Metro]] is able to perform '''remote build''' building different architecture stage3 from a binary compatible seeding stage3 (e.g. using a pentium4 stage3 to seed a <tt>Intel Core2 32bits</tt> stage3).  
+
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>).  
  
In the Metro terminology this is called a '''remote build''' (a stage 3 of a different, but binary compatible, architecture is used as a seed).  
+
Na terminologia Metro Isso é chamado de uma '''remote build''' (um stage 3 de uma arquitetura diferente, mas binariamente compatível, é utilizada como uma semente).  
What's not compatible? You can't use a <tt>Sparc</tt> architecture to generate an <tt>x86</tt> or <tt>ARM</tt> based stage and vice-versa. If you use a 32bit stage then you don't want to seed a 64bit build from it. Be sure that you are using a stage from the same architecture that you are trying to seed. Check [http://ftp.osuosl.org/pub/funtoo/funtoo-current/ Funtoo-current FTP Mirror] for a stage that is from the same Architecture that you will be building.   
+
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|Often, one build (ie. funtoo-current) can be used as a seed for another build such as funtoo-stable. However, hardened builds require hardened stages as seeds in order for the build to complete successfully.}}
+
{{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.}}
  
== Step 1: Set up Core_2 32bit repository ==
+
== Primeiro Passo: Definir o repositório Core_2 32bit ==
  
In this example, we're going to use this pentium4 funtoo-current stage3 to seed a new Core_2 32bit funtoo-current build. To get that done, we need to set up the pentium4 build directory as follows:
+
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>
 
<console>
Line 190: Line 190:
 
</console>
 
</console>
  
The steps we follow are similar to those we performed for a ''local build'' to set up our pentium4 directory for 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. We also didn't create the <tt>.control/version/stage{1,3}</tt> files because Metro will create them for us after it successfully builds a new stage1 and stage3. We are still using a <tt>stage3</tt> seed strategy, but we've set the build strategy to <tt>remote</tt>, which means that we're going to use a seed stage that's not from this particular subdirectory. Where are we going to get it from? The <tt>.control/remote</tt> directory contains this information, and lets Metro know that it should look for its seed stage3 in the <tt>/home/mirror/funtoo/funtoo-current/x86-32bit/pentium4</tt> directory. Which one will it grab? You guessed it -- the most recently built ''stage3'' (since our seed strategy was set to <tt>stage3</tt>) that has the version stamp of <tt>2010-12-24</tt>, as recorded in <tt>/home/mirror/funtoo-current/x86-32bit/pentium4/.control/version/stage</tt>. Now you can see how all those control files come together to direct Metro to do the right thing.
+
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> should be set to one of: <code>x86-32bit</code>, <code>x86-64bit</code> or <code>pure64</code> for PC-compatible systems. You must use a 32-bit build as a seed for other 32-bit builds, and a 64-bit build as a seed for other 64-bit builds.}}
+
{{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.}}
  
== Step 2: Building the Core_2 32bit stages ==
+
== Segundo Passo: Construir os stages para Core_2 32bit stages ==
  
Now, you could start building your new Core_2 32bit stage1/2/3 (plus openvz and vserver templates) by typing the following:
+
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>
 
<console>
Line 202: Line 202:
 
</console>
 
</console>
  
In that case, the produced stages are placed in the <tt>/home/mirror/funtoo/funtoo-current/x32-bit/core2_32/YYYY-MM-DD</tt> subdirectory.
+
Nesse caso, os stages gerados no subdiretório <tt>/home/mirror/funtoo/funtoo-current/x32-bit/core2_32/YYYY-MM-DD</tt> subdirectory.
  
== Step 3: The Next Build ==
+
== Terceiro Passo: O Próximo Build ==
  
At this point, you now have a new Core_2 32bit stage3, built using a "remote" pentium4 stage3. Once the first remote build completes successfully, metro will automatically change <code>.control/strategy/build</code> to be <code>local</code> instead of <code>remote</code>, so it will use the most recently-built Core_2 32bit stage3 as a seed for any new Core_2 32bit builds from now on.
+
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.
  
= Build your own tailored stage3 =
+
= Construa seu próprio stage3 adaptado =
  
Metro can be easily configured for building custom stage3 by including additional packages. Edit the following configuration file <tt>/root/metro/etc/builds/funtoo-current/build.conf</tt>:
+
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=
 
{{file|name=funtoo-current/build.conf|body=
 
[collect ../../fslayouts/funtoo/layout.conf]
 
[collect ../../fslayouts/funtoo/layout.conf]
Line 287: Line 287:
 
}}
 
}}
  
= Building Gentoo stages =
+
= Construindo stages do Gentoo =
  
Metro can also build Gentoo stages. After switching to Funtoo profile, see http://www.funtoo.org/Funtoo_Profiles metro require additional steps for this. We have an open bug for this -- it is simply due to the fact that we focus on ensuring Funtoo Linux builds and building Gentoo is a lower priority. Historical note: Funtoo Linux originally started as a fork of Gentoo Linux so that metro could reliably build Gentoo stages.
+
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.
http://www.funtoo.org/Funtoo_Profiles
+
http://www.funtoo.org/Pt-br/Funtoo_Profiles
  
= Advanced Features =
+
= Recursos Avançados =
  
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.
+
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.
  
== Repository Management ==
+
== Gerenciamento de Repositório ==
  
Metro includes a script in the {{c|scripts}} directory called {{c|buildrepo}}. Buildrepo serves as the heart of Metro's advanced repository management features.
+
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.
  
=== Initial Setup ===
+
=== Configuração Inicial ===
  
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:
+
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=
 
{{file|name=/root/.buildbot|lang=python|body=
Line 330: Line 330:
 
}}
 
}}
  
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.
+
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).
  
== Automated Builds ==
+
== Builds Automatizadas ==
  
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.  
+
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.  
  
To list the next build that will be performed, do this -- this is from my ARM build server:
+
Para listar a próxima que serão desenvolvidas, faço isso -- Esse vem do meu ARM build server:
  
 
{{console|body=
 
{{console|body=
Line 350: Line 350:
 
}}
 
}}
  
If no output is displayed, then all your builds are up-to-date.
+
Se nenhuma saída for exibida, então todos as suas builds estão atualizadas.
  
To actually run the next build, run {{c|buildbot.sh}}:
+
Para na verdade executar a próxima build, execute {{c|buildbot.sh}}:
  
 
{{console|body=
 
{{console|body=
Line 358: Line 358:
 
}}
 
}}
  
If you're thinking that {{c|buildbot.sh}} would be a good candidate for a cron job, you've got the right idea!
+
Se você está pensando que {{c|buildbot.sh}} seria uma boa candidata para um cron job, você teve a ideia certa!
  
=== List Builds ===
+
=== Listar Builds ===
  
To get a quick look at our repository, let's run the {{c|buildrepo fails}} command:
+
Para dar uma rápida olhada em nosso repositório, vamos executar o comando {{c|buildrepo fails}}:
  
 
{{console|body=
 
{{console|body=
Line 374: Line 374:
 
}}
 
}}
  
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:
+
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}} tries to build a stage and the build fails, the failcount is incremented.
+
* If {{c|buildbot.sh}} tenta construir um stage e a build falha, a failcount é incrementada.
* If the build succeeds for a particular build, the failcount is reset to zero.
+
* Se a build obtiver êxito para uma build particular, a failcount e redefinida para zero.
* Builds with the lowest failcount are prioritized by {{buildrepo}} to build next, to steer towards builds that are more likely to complete successfully.
+
* 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.
* Once the failcount reaches 3 for a particular build, it is removed from the build rotation.
+
* Uma vez que a failcount alcança 3 para uma build particular, ele é removido da build rotation.
  
 
=== Resetting Failcount ===
 
=== Resetting Failcount ===
Line 392: Line 392:
 
}}
 
}}
  
== Repository Maintenance ==
+
== Manutenção (Maintenance) do Repositório ==
  
A couple of repository maintenance tools are provided:
+
Uma dupla de ferramentas de manutenção do repositório são fornecidas:
  
* {{c|buildrepo digestgen}} will generate hash files for the archives in your repository, and clean up stale hashes.  
+
* {{c|buildrepo digestgen}} gerará arquivos hash para os arquivos em seu repositório, e limpará os hashes velhos.  
* {{c|buildrepo index.xml}} will create an index.xml file at the root of your repository, listing all builds available.
+
* {{c|buildrepo index.xml}} gerará um arquivo index.xml no root do seu repositório, listando todos os builds disponíveis.
* {{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.
+
* {{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.
  
== Distributed Repositories ==
+
== Repositórios Distribuídos ==
  
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:
+
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=
 
{{file|name=/root/.metro|desc=Excerpt of .metro config for master repository|body=

Latest revision as of 21:54, May 26, 2015

Metro é o build system para os stages Funtoo Linux e Gentoo Linux. Ele automatiza o processo de bootstrap.

Esse tutorial te guiará através da instalação, configuração e execução do Metro.

Esses outros documentos do Metro também estão disponíveis:


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 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 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.

Important

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 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 pentium4. O método recomendado de se fazer isso seria agarrar um stage3 tarball pentium4 existente para utilizar como seu seed stage. Será dito ao Metro que utilizr esse stage3 pentium4 existente para construir um novo stage1 para o mesmo pentium4. Para esse processo, o stage3 pentium4 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 pentium4. E o novo stage2 pentium4 serviria como build environment para a criação do novo stage3 pentium4.

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 pentium4 novo. Ao invés de iniciar a partir do stage3 pentium4 original novamente, provavelmente você configuraria o Metro para utilizar o stage3 pentium4 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 core2 32bit a partir do stage3 tarball do pentium4 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 local e remote builds, Metro pode ser configurado para adicionar e/ou remover pacotes individuais ao tarball final. Vamos dizer que você não possa viver sem app-misc/screen, 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 Git e o dev-python/boto (package not on wiki - please add) (opcional; necessário para suporte EC2) estejam instalados no seu sistema:

# emerge dev-vcs/git
# emerge dev-python/boto

Depois, clone o master git repository como a seguir:

# cd /root
# git clone git://github.com/funtoo/metro.git
# cp /root/metro/metro.conf ~/.metro

Você agora terá um diretório chamado /root/metro 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 FL-901.

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 ~/.metro que é o o arquivo de configuração mestre do Metro.

Note que path/install deve apontar para aonde o metro foi instalado. Aponte path/distfiles para aonde seus distfiles residem. Também defina path/mirror/owner e path/mirror/group 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 /home/mirror/funtoo. 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.

.metro - Metro configuration
# 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 /root/metro/subarch; cada subarch terá a extensão de arquivo .spec Example:

# 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

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 /home/mirror/funtoo, então assim Metro pode encontrá-la. Também precisaremos criar alguns "controles&quot especiais; arquivos em /home/mirror/funtoo, 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 (funtoo-current) construído para o pentium4, utilizando um stage3 pentium4 genérico como uma semente stage, então aqui o primeiro conjunto de passos que desempenharemos:

# install -d /home/mirror/funtoo/funtoo-current/x86-32bit/pentium4
# install -d /home/mirror/funtoo/funtoo-current/snapshots
# cd /home/metro/mirror/funtoo/funtoo-current/x86-32bit/pentium4
# install -d 2011-12-13
# cd 2011-12-13
# 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
# cd ..
# install -d .control/version
# echo "2011-12-13" > .control/version/stage3
# install -d .control/strategy
# echo local >  .control/strategy/build
# echo stage3 > .control/strategy/seed

OK, vamos rever os passos acima. Primeiro, criamos o diretório /home/mirror/funtoo/funtoo-current/x86-32bit/pentium4, ao qual é aonde Metro esperará encontrar builds pentium4 instáveis funtoo-current -- 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 2010-12-24 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/home/mirror/metro/funtoo-current/x86-32bit/pentium4, e dentro dele, geramos um diretório .control. Esse diretório e seus subdiretórios contem arquivos especiais que o Metro refere para determinar certo aspectos de seu comportamento. O arquivo .control/version/stage3 é 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 .control/version/stage3 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 .control/version/stage1 similar depois que ele construir com sucesso um stage1 funtoo-current para pentium4.

Definimos também os arquivos .control/strategy/build e .control/strategy/seed com valores de local e stage3 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 local, 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 stage3, 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:

# cd /root/metro
# scripts/ezbuild.sh funtoo-current pentium4

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 "${METRO_MIRROR}/funtoo-current/x32-bit/pentium4/YYYY-MM-DD", onde YYYY-MM-DD é a data de hoje no horário que o script ezbuild.sh 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 Intel Core2 32bits).

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 Sparc para gerar um stage baseado em x86 ou ARM 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 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:

#  cd /home/mirror/funtoo/funtoo-current/x86-32bit
# install -d core2_32
# cd core2_32
# install -d .control/strategy
# echo remote > .control/strategy/build
# echo stage3 > .control/strategy/seed
# install -d .control/remote
# echo funtoo-current > .control/remote/build
# echo x86-32bit > .control/remote/arch_desc
# echo pentium4 > .control/remote/subarch

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 .control/version/stage{1,3} 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 stage3, mas definimos a build strategy para remote, que significa que vamos utilizar uma seed stage que não é desse subdiretório particular. de onde vamos conseguir obtê-lo? O diretório .control/remote contem essa informação, e deixa o Metro saber que ele deve procurar seu seed stage3 dentro do diretório /home/mirror/funtoo/funtoo-current/x86-32bit/pentium4. Qual ele obterá? Você imaginou isso -- o stage3 mais recente construído (desde nossa seed strategy foi definido stage3) que contem a version stamp de 2010-12-24, como gravado em /home/mirror/funtoo-current/x86-32bit/pentium4/.control/version/stage. Agora você oide você como todas esses arquivos de controle se juntam para direcionar o Metro a fazer a coisa correta.

Note

arch_desc deve ser definido para uma das: x86-32bit, x86-64bit ou pure64 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:

# /root/metro/scripts/ezbuild.sh funtoo-current core2_32

Nesse caso, os stages gerados no subdiretório /home/mirror/funtoo/funtoo-current/x32-bit/core2_32/YYYY-MM-DD 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á .control/strategy/build para ser local ao invés de remote, 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 /root/metro/etc/builds/funtoo-current/build.conf:

funtoo-current/build.conf
[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/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. 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ê emerge sqlalchemy, como SQLite é utilizado como uma dependência.

Gerenciamento de Repositório

Metro inclui um script no diretório scripts chamado buildrepo. Buildrepo serve como o coração dos recursos avançados do gerenciamento de repositório do Metro.

Configuração Inicial

Para utilizar buildrepo, você primeiro precisará gerar um arquivo de configuração .buildbot. Aqui está o arquivo que eu utilizo no meu AMD Jaguar build server:

/root/.buildbot (python source code)
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 builds, arches e subarches. Essas variáveis dizem ao buildrepo quais builds, arches e subarches ele deve gerenciar. Uma função map_build() é também definida a qual 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 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 .buildbot tem sido gerado, as ferramentas buildrepo e buildbot.sh estão prontas para uso. Aqui está como elas funcionam. Essas ferramentas são desenvolvidas para manter seu repositório (path/mirror em /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:

# ./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 buildbot.sh:

# ./buildbot.sh


Se você está pensando que 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 buildrepo fails:

# ./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 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 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 Template: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 buildrepo zap:

# /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:

  • buildrepo digestgen gerará arquivos hash para os arquivos em seu repositório, e limpará os hashes velhos.
  • buildrepo index.xml gerará um arquivo index.xml no root do seu repositório, listando todos os builds disponíveis.
  • 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 buildbot do sistema, e aquelas que são armazenadas localmente e construídas remotamente. Esses builds devem ser limpos quando buildrepo clean for executados, mas não deve entrar na rotação build local (local build rotation). Para configurar isso, modifique /root/.buildbot e utilize as variáveis subarches e all_subarches:

/root/.metro - Excerpt of .metro config for master repository
# 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"
)