Metro/pt-br

Revision as of 16:01, May 23, 2015 by Tocadotux (Talk | contribs) (Distributed Repositories)

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:

{{#ask: |format=ul }}

Preface

Como o Metro Funciona

Metro é um sistema de construção automática do Funtoo, e é utilizado para construir os tarballs do Linux stage tarballs.

Metro Não pode gerar um stage tarball vazio. Para gerar um novo stage tarball, o 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 Package: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/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

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"
)