ubuntu-packaging-guide - en to pt_BR translation catalogue (330 entries)

en: autopkgtest: Automatic testing for packages
pt_BR: autopkgtest: Teste automático para pacotes

en: add a file called ``debian/tests/control`` which specifies the requirements for the testbed,
pt_BR: adicione um arquivo chamado ``debian/tests/control`` que especifica os requisitos para o testbed,

en: add the tests in ``debian/tests/``.
pt_BR: adicione os testes em ``debian/tests/``.

en: Testbed requirements
pt_BR: Requisitos do Testbed

en: Below we are having a look at the ``glib2.0`` source package. In a very simple case the file would look like this::
pt_BR: Abaixo estamos vendo o pacote fonte do ``glib2.0``. Em um caso muito simples, o arquivo se pareceria com isto::

en: For the test in ``debian/tests/build`` this would ensure that the packages ``libglib2.0-dev`` and ``build-essential`` are installed.
pt_BR: Para o teste em ``debian/tests/build`` isto deverá garantir que os pacotes ``libglib2.0-dev`` e ``build-essential`` estão instalados.

en: You can use ``@`` in the ``Depends`` line to indicate that you want all the packages installed which are built by the source package in question.
pt_BR: Você pode usar ``@`` na linha ``Depends`` para indicar que você quer que todos os pacotes instalados sejam compilados pelo pacote fonte em questão.

en: The actual tests
pt_BR: Os testes reais

en: The accompanying test for the example above might be:
pt_BR: O teste que deve acompanhar o exemplo acima poderia ser:

en: Here a very simple piece of C code is written to a temporary directory. Then this is compiled with system libraries (using flags and library paths as provided by `pkg-config`). Then the compiled binary, which just exercises some parts of core glib functionality, is run.
pt_BR: Aqui um pedaço simples de código em C é escrito em um diretório temporário. Então este é compilado com bibliotecas do sistema (usando flags e caminhos de biblioteca providos por `pkg-config`). Em seguida o binário compilado, que apenas utiliza partes da funcionalidade do núcleo glib, é executado.

en: Executing the test
pt_BR: Executando o teste

en: Further examples
pt_BR: Outros exemplos

en: This list is not comprehensive, but might help you get a better idea of how automated tests are implemented and used in Ubuntu.
pt_BR: Esta lista não é completa, mas pode ajudá-lo a ter uma ideia melhor de como testes automatizados são implementados e usados no Ubuntu.

en: Ubuntu infrastructure
pt_BR: Infraestrutura do Ubuntu

en: Getting the test into Ubuntu
pt_BR: Obtendo o teste no Ubuntu

en: The process of submitting an autopkgtest for a package is largely similar to :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. Essentially you simply:
pt_BR: O processo de envio de um autopkgtest para um pacote é muito semelhante a :doc:`corrigindo um erro no Ubuntu<./fixing-a-bug>`. Essencialmente, você simplesmente:

en: run ``bzr branch ubuntu:<packagename>``,
pt_BR: execute ``bzr branch ubuntu:<nomedopacote>``,

en: edit ``debian/control`` to enable the tests,
pt_BR: edite ``debian/control`` para habilitar os testes,

en: add the ``debian/tests`` directory,
pt_BR: adiciona o diretório ``debian/tests``,

en: add your test case(s) to ``debian/tests``,
pt_BR: adicione seu(s) caso(s) de teste em ``debian/tests``,

en: commit your changes, push them to Launchpad, propose a merge and get it reviewed just like any other improvement in a source package.
pt_BR: submeta suas mudanças, envie elas para o Launchpad, proponha a mesclagem e obtenha revisões apenas como qualquer outra melhoria no pacote fonte.

en: What you can do
pt_BR: O que você pode fazer

en: Backporting software updates
pt_BR: Backport de atualização de programas

en: Personal Package Archive (PPA)
pt_BR: Arquivo de pacotes pessoal (PPA)

en: Using a PPA has a number of benefits. It is fairly straight-forward, you don't need approval of anyone, but the downside of it is that your users will have to manually enable it. It is a non-standard software source.
pt_BR: Usar um PPA tem várias vantagens. É bastante simples e você não precisa da aprovação de ninguém, mas o lado negativo disso é que seus usuários terão que ativá-lo manualmente. É um software de fonte não-padrão.

en: Official Ubuntu Backports
pt_BR: Ubuntu Backports oficial

en: The Backports Project is a means to provide new features to users. Because of the inherent stability risks in backporting packages, users do not get backported packages without some explicit action on their part. This generally makes backports an inappropriate avenue for fixing bugs. If a package in an Ubuntu release has a bug, it should be fixed either through the :doc:`Security Update or the Stable Release Update process<./security-and-stable-release-updates>`, as appropriate.
pt_BR: O Projeto Backports é uma maneira de fornecer novos recursos aos usuários. Por causa dos riscos intrínsecos dos pacotes de backports, usuários não obtêm pacotes de backports sem algumas ações explícitas de suas partes. Isto geralmente faz com que backports sejam uma via inapropriada para correção de erros. Se um pacote em uma versão do Ubuntu possui um erro, ele deve ser corrigido através do :doc:`processo de atualização de segurança ou de atualização de versão estável <./security-and-stable-release-updates>`, como deve ser.

en: Once you determined you want a package to be backported to a stable release, you will need to test-build and test it on the given stable release. ``pbuilder-dist`` (in the ``ubuntu-dev-tools`` package) is a very handy tool to do this easily.
pt_BR: Uma vez que você tenha decidido que quer que se faça um backport de um pacote para uma versão estável, você precisará construí-lo e testá-lo nessa dada versão estável. "pbuider-dist" (no pacote "ubuntu-dev-tools") é uma ferramenta muito útil para se fazer isto facilmente.

en: To report the backport request and get it processed by the Backporters team, you can use the ``requestbackport`` tool (also in the ``ubuntu-dev-tools`` package). It will determine the intermediate releases that package needs to be backported to, list all reverse-dependencies, and file the backporting request.  Also will it include a testing checklist in the bug.
pt_BR: Para relatar um pedido de backport e tê-lo processado polo time de Backport, você pode utilizar a ferramenta "requestbackport" (também no pacote "ubuntu-dev-tools"). Isso irá determinar que as versões intermediárias para as quais será feito um backport do pacote, listar todas as dependências reversas, e arquivar o pedido de backport. Irá também incluir uma lista de verificação de teste no rastreador de erros.

en: Using Chroots
pt_BR: Usando o chroot

en: If you are running one version of Ubuntu but working on packages for another versions you can create the environment of the other version with a ``chroot``.
pt_BR: Se você está executando uma versão do Ubuntu mas os pacotes que está trabalhando são de outras versões você pode criar um ambiente da outra versão com um ``chroot``.

en: A ``chroot`` allows you to have a full filesystem from another distribution which you can work in quite normally.  It avoids the overhead of running a full virtual machine.
pt_BR: Um ``chroot`` lhe permite ter um sistema de arquivos completo a partir de outra distribuição, no qual se pode trabalhar normalmente. Isto evita a sobrecarga de uma máquina virtual inteira.

en: Creating a Chroot
pt_BR: Criando um chroot

en: Use the command ``debootstrap`` to create a new chroot::
pt_BR: Use o comando ``debootstrap`` para criar um novo chroot::

en: You can then work inside the chroot::
pt_BR: Você pode então trabalhar dentro do chroot::

en: Where you can install or remove any package you wish without affecting your main system.
pt_BR: Onde você pode instalar ou remover qualquer pacote que desejar sem afetar seu sistema principal.

en: You might want to copy your GPG/ssh keys and Bazaar configuration into the chroot so you can access and sign packages directly::
pt_BR: Você pode querer copiar suas chaves GPG/SSH e configuração do Bazaar para dentro do chroot, então você pode acessar e assinar pacotes diretamente::

en: To stop apt and other programs complaining about missing locales you can install your relevant language pack::
pt_BR: Para impedir que o apt e outros programas reclamem de falta de localizações, você deve instalar o pacote de linguagem relevante para você::

en: If you want to run X programs you will need to bind the /tmp directory into the chroot, from outside the chroot run::
pt_BR: Se você quer executar programas X será necessário vincular o diretório /tmp com o chroot, de fora do chroot execute::

en: Some programs may need you to bind /dev or /proc.
pt_BR: Alguns programas podem necessitar que os diretórios /dev ou /proc estejam vinculados com o chroot.

en: Alternatives
pt_BR: Alternativas

en: You can also set up pbuilder to pause when it comes across a build failure.  Copy C10shell from /usr/share/doc/pbuilder/examples into a directory and use the ``--hookdir=`` argument to point to it.
pt_BR: Você também pode configurar o pbuilder para pausar quando ele vem através de uma falha de construção.  Copie C10shell de /usr/share/doc/pbuilder/examples para dentro do diretório e use o argumento ``--hookdir=`` para apontá-lo.

en: Communication in Ubuntu Development
pt_BR: Comunicação no desenvolvimento do Ubuntu

en: In a project where thousands of lines of code are changed, lots of decisions are made and hundreds of people interact every day, it is important to communicate effectively.
pt_BR: Em um projeto aonde milhares de linhas de código são alterados, muitas decisões são tomadas e centenas de pessoas interagem todos os dias, é importante se comunicar de forma eficaz.

en: Mailing lists
pt_BR: Listas de e-mails

en: Mailing lists are a very important tool if you want to communicate ideas to a broader team and make sure that you reach everybody, even across timezones.
pt_BR: As listas de discussão são ferramentas muito importantes, se você quiser divulgar suas idéias para uma ampla equipe e ter certeza de que você alcance todos, até mesmo através de fusos horários diferentes.

en: In terms of development, these are the most important ones:
pt_BR: Em termos de desenvolvimento, estas são as mais importantes:

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (announce-only, the most important development announcements go here)
pt_BR: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (apenas anúncios, os mais importantes anúncios de desenvolvimento aqui)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (general Ubuntu development discussion)
pt_BR: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (discussão geral de desenvolvimento do Ubuntu)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (MOTU Team discussion, get help with packaging)
pt_BR: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (Time de discussão MOTU, obter ajuda com empacotamento)

en: IRC Channels
pt_BR: Canais de IRC

en: For real-time discussions, please connect to irc.freenode.net and join one or any of these channels:
pt_BR: Para discussões em tempo real, por favor conecte-se na rede irc.freenode.net e entre em qualquer um desses canais:

en: #ubuntu-devel (for general development discussion)
pt_BR: #ubuntu-devel (para discussão geral de desenvolvimento)

en: #ubuntu-motu (for MOTU team discussion and generally getting help)
pt_BR: #ubuntu-motu (Time de discussão MOTU e obtenção de ajuda em geral)

en: Basic Overview of the ``debian/`` Directory
pt_BR: Visão básica do diretório ``debian/``

en: This article will briefly explain the different files important to the packaging of Ubuntu packages which are contained in the ``debian/`` directory. The most important of them are ``changelog``, ``control``, ``copyright``, and ``rules``. These are required for all packages. A number of additional files in the ``debian/`` may be used in order to customize and configure the behavior of the package. Some of these files are discussed in this article, but this is not meant to be a complete list.
pt_BR: Este artigo explicará sucintamente sobre os diferentes arquivos contidos no diretório ``debian/``, importantes ao empacotamento Ubuntu. Os mais importantes são ``changelog``, ``control``, ``copyright`` e ``rules``. Eles são obrigatórios para todos os pacotes. Diversos arquivos adicionais dentro de ``debian/`` podem ser usados para personalizar e configurar o comportamento do pacote. Alguns desses arquivos são abordados neste artigo, o que não significa que esta seja a lista completa.

en: The changelog
pt_BR: O registro de mudanças

en: This file is, as its name implies, a listing of the changes made in each version. It has a specific format that gives the package name, version, distribution, changes, and who made the changes at a given time. If you have a GPG key (see: :doc:`Getting set up<./getting-set-up/>`), make sure to use the same name and email address in ``changelog`` as you have in your key. The following is a template ``changelog``::
pt_BR: Este arquivo é, como seu nome implica, uma listagem das mudanças feitas em cada versão. Tem um formato específico que dá o nome do pacote, versão, distribuição, mudanças e quem fez as mudanças em um momento determinado. Se você tiver uma chave GPG (see: :doc:`Getting set up<./getting-set-up/>`), certifique-se de usar no ``changelog`` o mesmo nome e endereço de e-mail da chave.  O documento a seguir é um modelo de ``changelog``::

en: The format (especially of the date) is important. The date should be in :rfc:`5322` format, which can be obtained by using the command ``date -R``. For convenience, the command ``dch`` may be used to edit changelog. It will update the date automatically.
pt_BR: O formato (principalmente da data) é importante. A data deve estar no formato da :rfc:`5322`, o qual pode ser obtido pelo uso do comando ``date -R``. Por conveniência, o comando ``dch`` pode ser usado para editar o arquivo de mudanças. Ele atualizará a data automaticamente.

en: Minor bullet points are indicated by a dash "-", while major points use an asterisk "*".
pt_BR: Pontos menos importantes são indicados por um traço "-", enquanto os pontos mais importantes usam um asterisco "*".

en: If you are packaging from scratch, ``dch --create`` (``dch`` is in the ``devscripts`` package) will create a standard ``debian/changelog`` for you.
pt_BR: Se você estiver empacotando do zero, ``dch --create`` (``dch`` está no pacote ``devscripts``) criará um ``debian/changelog`` padrão para você.

en: Here is a sample ``changelog`` file for hello::
pt_BR: Aqui está um exemplo de arquivo "changelog" para hello::

en: Notice that the version has a ``-0ubuntu1`` appended to it, this is the distro revision, used so that the packaging can be updated (to fix bugs for example) with new uploads within the same source release version.
pt_BR: Observe que a versão tem um ``-0ubuntu1`` acrescentado a ela, isso é a revisão da distro, usada para que o empacotamento possa ser atualizado (para corrigir falhas, por exemplo) com novos envios para a mesma versão de lançamento do fonte.

en: Ubuntu and Debian have slightly different package versioning schemes to avoid conflicting packages with the same source version. If a Debian package has been changed in Ubuntu, it has ``ubuntuX`` (where ``X`` is the Ubuntu revision number) appended to the end of the Debian version. So if the Debian hello ``2.6-1`` package was changed by Ubuntu, the version string would be ``2.6-1ubuntu1``. If a package for the application does not exist in Debian, then the Debian revision is ``0`` (e.g. ``2.6-0ubuntu1``).
pt_BR: Ubuntu e Debian são ligeiramente diferentes nos esquemas de versionamento de pacotes para evitar pacotes conflitantes com a mesma versão de código fonte. Se um pacote Debian foi mudado no Ubuntu, ele terá ``ubuntuX`` (onde ``X`` é o número da revisão Ubuntu) acrescentado ao final da versão Debian. Então, se o pacote Debian hello ``2.6-1`` sofresse alterações pelo Ubuntu, sua versão seria ``2.6-1ubuntu1``. Se um pacote para determinada aplicação não existir no Debian, então a revisão Debian será ``0`` (exemplo, ``2.6-0ubuntu1``).

en: The control file
pt_BR: O arquivo de controle

en: The ``control`` file contains the information that the package manager (such as ``apt-get``, ``synaptic``, and ``adept``) uses, build-time dependencies, maintainer information, and much more.
pt_BR: O arquivo ``control`` contém a informação que os gerenciadores de pacotes (tais como ``apt-get``, ``synaptic`` e ``adept``) usam, como dependências em tempo de construção de pacote, informações sobre o mantenedor e muito mais.

en: For the Ubuntu ``hello`` package, the ``control`` file looks something like this:
pt_BR: Para o pacote ``hello`` do Ubuntu, o arquivo ``control`` parece alguma coisa assim:

en: The first paragraph describes the source package including the list of packages required to build the package from source in the ``Build-Depends`` field. It also contains some meta-information such as the maintainer's name, the version of Debian Policy that the package complies with, the location of the packaging version control repository, and the upstream home page.
pt_BR: O primeiro parágrafo descreve o pacote fonte, incluindo a lista de pacotes necessários para construir o pacote a partir do fonte no campo ``Build-Depends``. Também contém algumas meta-informações tais como o nome do mantenedor, a versão de Política Debian que cumpre tal pacote, a localização do repositório de controle de versão de empacotamento e a página de internet do programa original.

en: Each additional paragraph describes a binary package to be built.
pt_BR: Cada parágrafo adicional descreve um pacote binário a ser construído.

en: The copyright file
pt_BR: O arquivo de direitos autorais

en: Generally, copyright information is found in the ``COPYING`` file in the program's source directory. This file should include such information as the names of the author and the packager, the URL from which the source came, a Copyright line with the year and copyright holder, and the text of the copyright itself. An example template would be::
pt_BR: Geralmente, informações sobre direitos autorais são encontradas no arquivo ``COPYING`` do diretório de arquivos fonte do programa. Este arquivo deve incluir informações como os nomes dos autores e do empacotador, a URL da qual o arquivo fonte foi baixado, uma linha com o ano e o titular do direito autoral e o próprio texto de direito autoral. Um exemplo de padrão seria::

en: The rules file
pt_BR: O arquivo de regras

en: The last file we need to look at is ``rules``. This does all the work for creating our package. It is a Makefile with targets to compile and install the application, then create the ``.deb`` file from the installed files. It also has a target to clean up all the build files so you end up with just a source package again.
pt_BR: O último arquivo que devemos olhar é o ``rules``. Ele faz todo trabalho de criar nosso pacote. Ele é um Makefile com regras para compilar e instalar a aplicação, então criar o arquivo ``.deb`` a partir dos arquivos instalados. Ele também tem uma regra para limpar todos os arquivos de construção para que você possa apenas com os arquivos fonte.

en: Here is a simplified version of the rules file created by ``dh_make`` (which can be found in the ``dh-make`` package):
pt_BR: Aqui é uma versão simplificada do arquivo de regras criado pelo ``dh_make`` (que pode ser encontrado no pacote ``dh-make``):

en: Let us go through this file in some detail. What this does is pass every build target that ``debian/rules`` is called with as an argument to ``/usr/bin/dh``, which itself will call all the necessary ``dh_*`` commands.
pt_BR: Vamos passar com mais detalhes sobre este arquivo. O que ele faz é passar por todas as regras de construção que ``debian/rules`` é chamado com argumentos para ``/usr/bin/dh``, no qual ele mesmo chamará todos os comandos ``dh_*`` necessários.

en: ``dh`` runs a sequence of debhelper commands. The supported sequences correspond to the targets of a ``debian/rules`` file: "build", "clean", "install", "binary-arch", "binary-indep", and "binary". In order to see what commands are run in each target, run::
pt_BR: "dh" executa uma sequência de comandos debhelper. As sequências suportadas correspondem às regras de um arquivo "debian/rules":  "build", "clean", "install", "binary-arch", "binary-indep" e "binary". Para ver quais comandos são executados em cada regra, execute::

en: Commands in the binary-indep sequence are passed the "-i" option to ensure they only work on binary independent packages, and commands in the binary-arch sequences are passed the "-a" option to ensure they only work on architecture dependent packages.
pt_BR: Comandos na sequência binary-indep são passados com a opção "-i" para garantir que funcionarão apenas em pacotes binário independentes e comandos na sequência binary-arch são passados com a opção "-a" para garantir que funcionarão apenas em pacotes dependentes de arquiteturas.

en: Each debhelper command will record when it's successfully run in ``debian/package.debhelper.log``. (Which dh_clean deletes.) So dh can tell which commands have already been run, for which packages, and skip running those commands again.
pt_BR: Cada comando debhelper gravará em ``debian/package.debhelper.log`` quando executado com sucesso. (O qual dh_clean apaga.) então dh pode dizer quais comandos foram executados, para quais pacotes e assim evitar rodar os mesmos comandos novamente.

en: Each time ``dh`` is run, it examines the log, and finds the last logged command that is in the specified sequence. It then continues with the next command in the sequence. The ``--until``, ``--before``, ``--after``, and ``--remaining`` options can override this behavior.
pt_BR: Cada vez que o ``dh`` roda, ele examina o registro e procura pelo último comando registrado que está numa sequência especificada. Então, ele continua com o comando seguinte. As opções `--until``, ``--before``, ``--after`` e ``--remaining`` podem sobrescrever este comportamento.

en: If ``debian/rules`` contains a target with a name like ``override_dh_command``, then when it gets to that command in the sequence, ``dh`` will run that target from the rules file, rather than running the actual command. The override target can then run the command with additional options, or run entirely different commands instead. (Note that to use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
pt_BR: Se o "debian/rules" contiver um alvo com um nome  como "override_dh_command",  então quando ele receber este comando o "dh" executará aquele alvo a partir do arquivo rules, em vez de executar o comando real. A substituição do alvo pode então executar o comando com opções adicionais, ou executar comandos totalmente diferentes. (Note que para usar este recurso, você deve construir as dependências com o debhelper 7.0.50 ou superior.)

en: Have a look at ``/usr/share/doc/debhelper/examples/`` and ``man dh`` for more examples. Also see `the rules section (Section 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ of the Debian Policy Manual.
pt_BR: Veja em ``/usr/share/doc/debhelper/examples/`` e ``man dh`` para mais exemplos. Veja também `a seção de regras (Seção 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ do Manual de Políticas do Debian.

en: Additional Files
pt_BR: Arquivos adicionais

en: The install file
pt_BR: O arquivo de instalação

en: The ``install`` file is used by ``dh_install`` to install files into the binary package. It has two standard use cases:
pt_BR: O arquivo ``install` é usado por ``dh_install`` para instalar arquivos no pacote binário. Ele possui dois casos de uso padrão:

en: To install files into your package that are not handled by the upstream build system.
pt_BR: Para arquivos de instalação dentro do seu pacote que não são manipulados pelo sistema de construção do upstream.

en: Splitting a single large source package into multiple binary packages.
pt_BR: Dividindo um grande e único pacote fonte em múltiplos pacotes binários.

en: In the first case, the ``install`` file should have one line per file installed, specifying both the file and the installation directory. For example, the following ``install`` file would install the script ``foo`` in the source package's root directory to ``usr/bin`` and a desktop file in the ``debian`` directory to ``usr/share/applications``::
pt_BR: No primeiro caso, o arquivo ``install`` deveria ter uma linha por arquivo instalado, especificando ambos arquivos e o local da instalação. Por exemplo, o seguinte arquivo ``install`` instalaria o script ``foo`` na fonte do pacote do diretório raiz para ``usr/bin`` e um atalho no diretório ``debian`` para ``usr/share/applications``::

en: While ``foo-common.install`` containing only the architecture independent file might look like::
pt_BR: Enquanto ``foo-common.install`` contendo apenas o arquivo independente da arquitetura pode parecer como::

en: This would create two binary packages, ``foo`` and ``foo-common``. Both would require their own paragraph in ``debian/control``.
pt_BR: Isso criará dois pacotes binários, ``foo`` e ``foo-common``. Ambos necessitam de seu próprio parágrafo em ``debian/control``.

en: See ``man dh_install`` and the `install file section (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_  of the Debian New Maintainers' Guide for additional details.
pt_BR: Veja "man dh_install" e a "seção de arquivo de instalação (Seção 5,11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>"_ do Novo Guia dos Mantenedores do Debian para detalhes adicionais.

en: The watch file
pt_BR: O arquivo watch

en: The ``debian/watch`` file allows us to check automatically for new upstream versions using the tool ``uscan`` found in the ``devscripts`` package. The first line of the watch file must be the format version (3, at the time of this writing), while the following lines contain any URLs to parse. For example::
pt_BR: O arquivo "debian/watch" nos permite verificar automaticamente a existência de novas versões no upstream usando a ferramenta "uscan" encontrada no pacote "devscripts". A primeira linha do arquivo watch deve ser a versão do formato (3, quando este texto foi escrito), enquanto que as linhas seguintes contém quaisquer URLs a serem analisadas. Por exemplo::

en: Running ``uscan`` in the root source directory will now compare the upstream version number in ``debian/changelog`` with the latest available upstream version. If a new upstream version is found, it will be automatically downloaded. For example::
pt_BR: Ao executar ``uscan`` no diretório raiz dos fontes irá comparar o número da versão no upstream em ``debian/changelog`` com a última versão disponível no upstream. Se uma nova versão upstream for encontrada, ela será baixada automaticamente. Por exemplo::

en: For further information, see ``man uscan`` and the `watch file section (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ of the Debian Policy Manual.
pt_BR: Para maiores informações, veja ``man uscan`` e a `seção do arquivo watch (Seção 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ do Manual de políticas do Debian.

en: For a list of packages where the ``watch`` file reports they are not in sync with upstream see `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.
pt_BR: Para uma lista dos pacotes cujo arquivo "watch" relata não estarem sincronizados com o upstream, consulte `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.

en: The source/format file
pt_BR: O arquivo source/format

en: This file indicates the format of the source package. It should contain a single line indicating the desired format:
pt_BR: Este arquivo indica o formato do pacote fonte. Ele deve conter uma única linha indicando o formato desejado:

en: ``3.0 (native)`` for Debian native packages (no upstream version)
pt_BR: ``3.0 (native)`` para pacotes nativos do Debian (sem versão do upstream)

en: ``3.0 (quilt)`` for packages with a separate upstream tarball
pt_BR: ``3.0 (quilt)`` para pacotes com um tarball separado do upstream

en: ``1.0`` for packages wishing to explicitly declare the default format
pt_BR: ``1.0`` para pacotes que desejam declarar explicitamente o formato padrão

en: Currently, the package source format will default to 1.0 if this file does not exist. You can make this explicit in the source/format file. If you choose not to use this file to define the source format, Lintian will warn about the missing file. This warning is informational only and may be safely ignored.
pt_BR: Atualmente, o formato fonte do pacote será padronizada para 1.0 se o arquivo não existir. Você pode fazer isso explicitamente no arquivo/formato fonte. Se você escolher não utilizar este arquivo para definir o formato fonte, o Lintian irá lhe avisar sobre o arquivo ausente. Este aviso é apenas uma informação e pode ser ignorado com segurança.

en: You are encouraged to use the newer 3.0 source format. It provides a number of new features:
pt_BR: Você é encorajado a usar o mais recente formato de fonte, o 3.0. Ele fornece uma quantia de novos recursos:

en: Support for additional compression formats: bzip2, lzma and xz
pt_BR: Suporte para formatos de compressão adicionais: bzip2, lzma e xz

en: Support for multiple upstream tarballs
pt_BR: Suporte para múltiplos tarballs do upstream

en: Not necessary to repack the upstream tarball to strip the debian directory
pt_BR: Não é necessário reempacotar o tarball do upstream para retirar o diretório debian

en: Debian-specific changes are no longer stored in a single .diff.gz but in multiple patches compatible with quilt under ``debian/patches/``
pt_BR: Mudanças específicas do Debian não são armazenadas em um único .diff.gz, mas em múltiplos patches compatíveis com o quilt em ``debian/patches/``

en: Additional Resources
pt_BR: Recursos adicionais

en: Fixing a bug in Ubuntu
pt_BR: Corrigindo um erro no Ubuntu

en: Introduction
pt_BR: Introdução

en: If you followed the instructions to :doc:`get set up with Ubuntu Development<./getting-set-up>`, you should be all set and ready to go.
pt_BR: Se você seguiu as instruções do :doc:`prepare-se para o Desenvolvimento do Ubuntu<./getting-set-up>`, você deve estar pronto para começar.

en: As you can see in the image above, there is no surprises in the process of fixing bugs in Ubuntu: you found a problem, you get the code, work on the fix, test it, push your changes to Launchpad and ask for it to be reviewed and merged. In this guide we will go through all the necessary steps one by one.
pt_BR: Como você pode observar na imagem acima, não há surpresas no processo de correção de erros no Ubuntu: você encontra um problema, obtém o código, trabalha para corrigi-lo, testa, envia as alterações para o Launchpad e pede para que sejam revisadas e incorporadas. Neste guia nós passaremos por todas as etapas necessárias, uma por uma.

en: Finding the problem
pt_BR: Encontrando o problema

en: There are a lot of different ways to find things to work on. It might be a bug report you are encountering yourself (which gives you a good opportunity to test the fix), or a problem you noted elsewhere, maybe in a bug report.
pt_BR: Há várias maneiras diferentes de encontrar coisas nas quais trabalhar. Pode ser um relatório de erro que você mesmo encontrou (o que lhe dá uma boa oportunidade para testar a correção), ou um problema que você encontrou em outro lugar, talvez num relatório de erro.

en: Figuring out what to fix
pt_BR: Descobrindo o que corrigir

en: If you don't know the source package containing the code that has the problem, but you do know the path to the affected program on your system, you can discover the source package that you'll need to work on.
pt_BR: Se você não sabe qual o pacote fonte que contém o código que tem o problema, mas você sabe o caminho para o programa afetado no seu sistema, você pode descobrir o pacote fonte no qual você precisa trabalhar.

en: This would print out::
pt_BR: Isso deverá imprimir::

en: ``apt-cache`` is part of the standard installation of Ubuntu.
pt_BR: ``apt-cache`` é parte da instalação padrão do Ubuntu.

en: Confirming the problem
pt_BR: Confirmando o problema

en: Let's say the package ``bumprace`` does not have a homepage in its package description. As a first step you would check if the problem is not solved already. This is easy to check, either take a look at Software Center or run::
pt_BR: Digamos que o pacote "bumprace" não tenha uma página na Internet na sua descrição de pacote. Como primeiro passo, você iria verificar se o problema já esta solucionado. Isto é fácil de verificar, dê uma olhado na Central de Programas ou execute::

en: The output should be similar to this::
pt_BR: A saída deve ser similar a isto::

en: A counter-example would be ``gedit``, which has a homepage set::
pt_BR: Um contra-exemplo seria o "gedit", que tem uma página na Internet definida::

en: Sometimes you will find that a particular problem you are looking into is already fixed. To avoid wasting efforts and duplicating work it makes sense to first do some detective work.
pt_BR: Algumas vezes você ira descobrir que um problema em particular que você está analisando já está corrigido. Para evitar desperdiçar esforço e duplicar trabalho, faz sentido fazer um trabalho de detetive antes.

en: Research bug situation
pt_BR: Pesquisar situação da falha

en: First we should check if a bug for the problem exists in Ubuntu already. Maybe somebody is working on a fix already, or we can contribute to the solution somehow. For Ubuntu we have a quick look at https://bugs.launchpad.net/ubuntu/+source/bumprace and there is no open bug with our problem there.
pt_BR: Primeiro temos que verificar um relatório de erro para o problema já existe no Ubuntu. Talvez alguém já esteja trabalhando em uma correção, ou que possamos contribuir para solução de alguma maneira. Para o Ubuntu, nós demos uma rápida olhada em https://bugs.launchpad.net/ubuntu/+source/bumprace e não há um relatório de erro ara o problema lá.

en: For Ubuntu the URL ``https://bugs.launchpad.net/ubuntu/+source/<package>`` should always take to the bug page of the source package in question.
pt_BR: Para o Ubuntu a URL ``https://bugs.launchpad.net/ubuntu/+source/<pacote>`` deve sempre levar até a página de falhas do pacote fonte em questão.

en: For Debian, which is the major source for Ubuntu's packages, we have a look at http://bugs.debian.org/src:bumprace and can't find a bug report for our problem either.
pt_BR: Para o Debian, que é a maior fonte para os pacotes do Ubuntu, nós demos uma olhada em http://bugs.debian.org/src:bumprace e não achamos um relatório para o nosso problema também.

en: For Debian the URL ``http://bugs.debian.org/src:<package>`` should always take to the bug page of the source package in question.
pt_BR: Para o Debian a URL ``http://bugs.debian.org/src:<pacote>`` deve sempre levar até a página de falhas do pacote fonte em questão.

en: Offering help
pt_BR: Oferecendo ajuda

en: If you found an open bug and it is not assigned to somebody and you are in a position to fix it, you should comment on it with your solution. Be sure to include as much information as you can: Under which circumstances does the bug occur? How did you fix the problem? Did you test your solution?
pt_BR: Se você encontrou um relatório de erro aberto, se ele não estiver atribuído a alguém e você puder corrigi-lo, você deverá comentar no relatório a sua solução. Certifique-se de incluir toda a informação que puder: em que circunstâncias o erro acontece? Como você corrigiu o problema? Você testou a sua solução?

en: If no bug report has been filed, you can file a bug for it. What you might want to bear in mind is: Is the issue so small that just asking for somebody to commit it is good enough? Did you manage to only partially fix the issue and you want to at least share your part of it?
pt_BR: Se nenhum relatório de erro foi arquivado, você pode arquivá-lo. O que você deve ter em mente é: o problema é tão pequeno que pedir para alguém para repará-lo seria suficiente? Você conseguiu corrigir apenas parcialmente o problema e você quer ao menos compartilhar a sua parte na correção?

en: It is great if you can offer help and will surely be appreciated.
pt_BR: Isso é ótimo se você pode oferecer ajuda e certamente será apreciado.

en: Getting the code
pt_BR: Obtendo o código

en: Work on a fix
pt_BR: trabalhar em uma correção

en: There are entire books written about finding bugs, fixing them, testing them, etc. If you are completely new to programming, try to fix easy bugs such as obvious typos first. Try to keep changes as minimal as possible and document your change and assumptions clearly.
pt_BR: Há livros inteiros escritos sobre encontrar erros, corrigi-los, testá-los, etc. Se você for um programador novato, tente corrigir erros fáceis primeiro, como erros de digitação óbvios. Tente alterar o mínimo possível, e documente sua alteração e suposições com clareza.

en: Before working on a fix yourself, make sure to investigate if nobody else has fixed it already or is currently working on a fix. Good sources to check are:
pt_BR: Antes de trabalhar na correção você mesmo, tenha certeza de investigar se ninguém já corrigiu ou está trabalhando na correção para a falha. Boas fontes para verificar são:

en: Upstream (and Debian) bug tracker (open and closed bugs),
pt_BR: Rastreamento de erros upstream (e Debian) de erros abertos e fechados,

en: Upstream revision history (or newer release) might have fixed the problem,
pt_BR: Histórico de revisão do upstream (ou lançamento recente) poderia ter corrigido o problema,

en: bugs or package uploads of Debian or other distributions.
pt_BR: bugs ou envio de pacotes do Debian ou outras distribuições.

en: This will copy the packaging to a temporary directory.  You can now edit files with a text editor or apply patches from upstream, for example::
pt_BR: Isso copiará o empacotamento para um diretório temporário.  Agora você pode editar arquivos com um editor de textos ou aplicar patches do upstream, por exemplo::

en: After editing the file type ``exit`` or press ``control-d`` to quit the temporary shell.  The new patch will have been added into ``debian/patches``.
pt_BR: Após editar o tipo de arquivo ``exit`` ou pressione ``control-d`` para sair do shell temporário. O novo patch será adicionado em ``debian/patches``.

en: Documenting the fix
pt_BR: Documentando a correção

en: It is very important to document your change sufficiently so developers who look at the code in the future won't have to guess what your reasoning was and what your assumptions were. Every Debian and Ubuntu package source includes ``debian/changelog``, where changes of each uploaded package are tracked.
pt_BR: É muito importante documentar a sua alteração suficientemente de maneira que os desenvolvedores que olharem o código no futuro não terão que adivinhar qual foi o seu raciocínio e quais foram a suposições. Todo pacote fonte do Debian e do Ubuntu inclui o "debian/changelog", onde alterações em cada pacote enviado são rastreadas.

en: The easiest way to update this is to run::
pt_BR: A maneira mais fácil de atualizar isto é executar::

en: This will add a boilerplate changelog entry for you and launch an editor where you can fill in the blanks. An example of this could be::
pt_BR: Isto irá adicionar um modelo entrada de registro de alteração para você e iniciar um editor onde você possa preencher os espaços em branco. Um exemplo disso poderia ser::

en: With that out of the way, let's focus on the actual changelog entry itself: it is very important to document:
pt_BR: Com isso fora do caminho, vamos nos concentrar na entrada do registro de alteração propriamente dita: é muito importante documentar:

en: Testing the fix
pt_BR: Testando a correção

en: To build a test package with your changes, run these commands::
pt_BR: Para construir um pacote de teste com suas alterações, e execute estes comandos::

en: This will take you through a series of steps to make sure the bug ends up in the correct place. Be sure to review the diff again to make sure it does not include random changes you made earlier.
pt_BR: Isto lhe levará por uma série de passos para assegurar que o erro vá parar no lugar correto. Assegure-se de revisar o diff novamente para ter certeza de que não inclui alterações aleatórias que você tenha feito antes.

en: Communication is important, so when you add some more description to it to the inclusion request, be friendly, explain it well.
pt_BR: Comunicação é importante, então quando você adicionar alguma descrição para solicitar a inclusão, seja amigável, explique ela bem.

en: If everything went well you should get a mail from Debian's bug tracking system with more information. This might sometimes take a few minutes.
pt_BR: Se tudo deu certo você deverá receber um e-mail do sistema de rastreamento de erros do Debian com mais informações. Isto pode levar alguns minutos.

en: Additional considerations
pt_BR: Considerações adicionais

en: If you find a package and find that there are a couple of trivial things you can fix at the same time, do it. This will speed up review and inclusion.
pt_BR: Se você encontrar um pacote e achar que há algumas coisas pequenas que você pode corrigir ao mesmo tempo, faça isso. Isto irá acelerar a revisão e a inclusão.

en: If there are multiple big things you want to fix, it might be advisable to send individual patches or merge proposals instead. If there are individual bugs filed for the issues already, this makes it even easier.
pt_BR: Se há várias coisas grandes que você queira corrigir, é prudente que você envie patches individuais ou propostas de mesclagem. Se houver erros individuais já arquivados para esses problemas, isto facilita ainda mais.

en: Fixing the issue
pt_BR: Corrigindo o problema

en: Getting Set Up
pt_BR: Guia de configuração

en: There are a number of things you need to do to get started developing for Ubuntu. This article is designed to get your computer set up so that you can start working with packages, and upload your packages to Ubuntu's hosting platform, Launchpad. Here's what we'll cover:
pt_BR: Há várias coisas que você precisa saber para começar a desenvolver para o Ubuntu. Esta artigo foi desenvolvido para deixar o seu computador preparado para que você possa começar a trabalhar com pacotes e enviá-los para a plataforma que hospeda o Ubuntu, o Launchpad. Eis o que vamos cobrir:

en: Installing packaging-related software. This includes:
pt_BR: Instalando pacotes de programas relacionados. Isto inclui:

en: Ubuntu-specific packaging utilities
pt_BR: Utilitários de empacotamento específicos do Ubuntu

en: Encryption software so your work can be verified as being done by you
pt_BR: Programas de criptografia para que seu trabalho possa ser verificado se foi feito por você

en: Additional encryption software so you can securely transfer files
pt_BR: Programas adicionais de criptografia para que você possa transferir seus arquivos com segurança

en: Creating and configuring your account on Launchpad
pt_BR: Criando e configurando sua conta no Launchpad

en: Setting up your development environment to help you do local builds of packages, interact with other developers, and propose your changes on Launchpad.
pt_BR: Configurando o seu ambiente de desenvolvimento para ajudá-lo a fazer compilações de pacotes locais, interagir com outros desenvolvedores, e propor as alterações no Launchpad.

en: It is advisable to do packaging work using the current development version of Ubuntu. Doing so will allow you to test changes in the same environment where those changes will actually be applied and used.
pt_BR: É recomendado fazer o trabalho de empacotamento utilizando a versão do Ubuntu que atualmente estiver em desenvolvimento. Isto irá permitir que você teste as alterações no mesmo ambiente em que elas serão aplicadas e utilizadas.

en: Install basic packaging software
pt_BR: Instalar os programas de empacotamento básico

en: This command will install the following software:
pt_BR: Este comando instalará os seguintes programas:

en: ``pbuilder`` -- a tool to do reproducible builds of a package in a clean and isolated environment.
pt_BR: ``pbuilder`` -- uma ferramenta para fazer a reprodução da construção dos pacotes em um ambiente limpo e isolado.

en: ``ubuntu-dev-tools`` (and ``devscripts``, a direct dependency) -- a collection of tools that make many packaging tasks easier.
pt_BR: "ubuntu-dev-tools" (e "devscripts", uma dependência direta) -- uma coleção de ferramentas para tornar mais fácil muitas tarefas de empacotamento.

en: ``apt-file`` provides an easy way to find the binary package that contains a given file.
pt_BR: ``apt-file`` fornece um caminho fácil para pesquisar um pacote binário que contém o determinado arquivo.

en: Create your GPG key
pt_BR: Criar sua chave GPG

en: To generate a new GPG key, run::
pt_BR: Para gerar uma nova chave GPG, execute::

en: Now GPG will create a key for you, which can take a little bit of time; it needs random bytes, so if you give the system some work to do it will be just fine.  Move the cursor around, type some paragraphs of random text, load some web page.
pt_BR: Agora o GPG irá criar uma chave para você, o que pode levar uma pouco de tempo. Ele precisa de bytes aleatórios, então será bom se você fornecer ao sistema algum trabalho para fazer. Mova o cursor pela tela, digite alguns parágrafos de texto aleatório, carregue uma página da Internet.

en: Once this is done, you will get a message similar to this one::
pt_BR: uma vez feito isso, você receberá uma mensagem semelhante a esta::

en: In this case ``43CDE61D`` is the *key ID*.
pt_BR: Neste caso, ``43CDE61D`` é o *ID da chave*.

en: Next, you need to upload the public part of your key to a keyserver so the world can identify messages and files as yours. To do so, enter::
pt_BR: A seguir, você deve enviar a parte pública de sua chave para um servidor de chaves para que o mundo possa identificar mensagens e arquivos como sendo seus. Para fazer isso, digite::

en: Create your SSH key
pt_BR: Criar sua chave SSH

en: To generate an SSH key, enter::
pt_BR: Para gerar uma chave SSH, digite::

en: The default file name usually makes sense, so you can just leave it as it is. For security purposes, it is highly recommended that you use a passphrase.
pt_BR: O nome de arquivo padrão geralmente faz sentido, então você pode deixar como está. Por motivo de segurança, é altamente recomendado que você utilize uma frase secreta.

en: Set up pbuilder
pt_BR: Configurando o pbuilder

en: ``pbuilder`` allows you to build packages locally on your machine. It serves a couple of purposes:
pt_BR: ``pbuilder`` permite você construir pacotes localmente em sua máquina. Ele serve para vários propósitos:

en: The build will be done in a minimal and clean environment. This helps you make sure your builds succeed in a reproducible way, but without modifying your local system
pt_BR: A construção será feita em um sistema mínimo e limpo. Isto ajuda a assegurar que suas construções sejam feitas com sucesso de uma maneira reprodutível, sem modificar seu sistema local

en: There is no need to install all necessary *build dependencies* locally
pt_BR: Não há necessidade de instalar todas as *dependências de construção* localmente

en: You can set up multiple instances for various Ubuntu and Debian releases
pt_BR: Você pode configurar múltiplas instâncias de várias versões do Ubuntu e do Debian

en: Setting ``pbuilder`` up is very easy, run::
pt_BR: Configurar o ``pbuilder`` é muito fácil, execute::

en: Get set up to work with Launchpad
pt_BR: Prepare-se para trabalhar com o Launchpad

en: With a basic local configuration in place, your next step will be to configure your system to work with Launchpad. This section will focus on the following topics:
pt_BR: Com uma configuração local básica estabelecida, seu próximo passo será configurar o seu sistema para trabalhar com o Launchpad. Esta seção irá se concentrar nos seguintes tópicos:

en: What Launchpad is and creating a Launchpad account
pt_BR: O que o Launchpad é e criando uma conta nele

en: Uploading your GPG and SSH keys to Launchpad
pt_BR: Enviando suas chaves GPG e SSH para o Launchpad

en: About Launchpad
pt_BR: Sobre o Launchpad

en: Launchpad is the central piece of infrastructure we use in Ubuntu. It not only stores our packages and our code, but also things like translations, bug reports, and information about the people who work on Ubuntu and their team memberships.  You will also use Launchpad to publish your proposed fixes, and get other Ubuntu developers to review and sponsor them.
pt_BR: O Launchpad é uma peça central da infraestrutura que usamos no Ubuntu. Ela não só armazena nossos pacotes e nossos códigos, mas também coisas como traduções, relatórios de erros, e informações sobre as pessoas que trabalham no Ubuntu e os seus grupos de membros. Você também irá usar o Launchpad para publicar propostas de correções, e conseguir outros desenvolvedores para revisão e orientação.

en: You will need to register with Launchpad and provide a minimal amount of information. This will allow you to download and upload code, submit bug reports, and more.
pt_BR: Você irá precisar se registrar no Launchpad e fornecer algumas informações mínimas. Isto irá permitir que você baixe e envie códigos, envie relatórios de erros e mais.

en: Besides hosting Ubuntu, Launchpad can host any Free Software project. For more information see the `Launchpad Help wiki <https://help.launchpad.net/>`_.
pt_BR: Além de hospedar o Ubuntu, o Launchpad pode hospedar qualquer projeto de Software Livre. Para mais informações, veja a `wiki de ajuda do Launchpad <https://help.launchpad.net/>`_.

en: Get a Launchpad account
pt_BR: Obter uma conta do Launchpad

en: Launchpad's registration process will ask you to choose a display name. It is encouraged for you to use your real name here so that your Ubuntu developer colleagues will be able to get to know you better.
pt_BR: O processo de registro do Launchpad irá pedir que você escolha um nome de exibição. O uso do nome real é encorajado aqui, de modo que seus colegas desenvolvedores do Ubuntu sejam capazes de lhe conhecer melhor.

en: When you register a new account, Launchpad will send you an email with a link you need to open in your browser in order to verify your email address. If you don't receive it, check in your spam folder.
pt_BR: Quando você registrar uma nova conta, o Launchpad enviará um email com um link que precisa ser aberto no seu navegador para verificar o seu endereço de email. Se você não recebê-lo, verifique na sua pasta de spam.

en: Upload your GPG key to Launchpad
pt_BR: Enviar sua chave GPG para o Launchpad

en: To find about your GPG fingerprint, run::
pt_BR: Para pesquisar sobre sua impressão digital GPG, execute::

en: and it will print out something like::
pt_BR: e será exibido alguma coisa como::

en: Head to https://launchpad.net/~/+editpgpkeys and copy the "Key fingerprint" into the text box. In the case above this would be ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Now click on "Import Key".
pt_BR: Vá para https://launchpad.net/~/+editpgpkeys e copie a "Key fingerprint" na caixa de texto. No caso acima seria "5C28 0144 FB08 91C0 2CF3 37AC 6F0B F90F 43CD E61D". Agora clique em "Import Key".

en: Launchpad will use the fingerprint to check the Ubuntu key server for your key and, if successful, send you an encrypted email asking you to confirm the key import. Check your email account and read the email that Launchpad sent you. `If your email client supports OpenPGP encryption, it will prompt you for the password you chose for the key when GPG generated it. Enter the password, then click the link to confirm that the key is yours.`
pt_BR: O Launchpad irá usar a impressão digital para verificar a sua chave no servidor de chaves do Ubuntu e, se tudo ocorrer bem, enviar para você um e-mail criptografado pedindo para confirmar a importação da chave. Verifique a sua conta de e-mail e leia a mensagem que o Launchpad lhe enviou. "Se o seu cliente de e-mail tiver suporte a criptografia OpenPGP, ele irá pedir a senha que você escolheu para a chave quando o GPG a gerou. Digite a senha, e então clique no link para confirmar que a chave é sua".

en: Back on the Launchpad website, use the Confirm button and Launchpad will complete the import of your OpenPGP key.
pt_BR: De volta ao site do Launchpad, clique no botão Confirm e o Launchpad irá completar a importação da sua chave OpenPGP.

en: Find more information at https://help.launchpad.net/YourAccount/ImportingYourPGPKey
pt_BR: Encontre mais informações em https://help.launchpad.net/YourAccount/ImportingYourPGPKey

en: Upload your SSH key to Launchpad
pt_BR: Enviar sua chave SSH para o Launchpad

en: Configure your shell
pt_BR: Configurar seu shell

en: Now save the file and either restart your terminal or run::
pt_BR: Agora salve o arquivo e reinicie o seu terminal ou execute::

en: (If you do not use the default shell, which is `bash`, please edit the configuration file for that shell accordingly.)
pt_BR: (se você não usa o shell padrão, que o é "bash", favor editar devidamente o arquivo de configuração para o seu shell.)

en: Ubuntu Packaging Guide
pt_BR: Guia de Empacotamento do Ubuntu

en: Ubuntu is not only a free and open source operating system, its platform is also open and developed in a transparent fashion. The source code for every single component can be obtained easily and every single change to the Ubuntu platform can be reviewed.
pt_BR: O Ubuntu não é somente um sistema operacional livre e de código-aberto, sua plataforma também é aberta e desenvolvida de maneira transparente. O código-fonte de cada um dos componentes pode ser obtido facilmente e toda mudança na plataforma do Ubuntu pode ser revisada.

en: This means you can actively get involved in improving it and the community of Ubuntu platform developers is always interested in helping peers getting started.
pt_BR: Isto significa que você pode se envolver ativamente na melhoria dele e a comunidade de desenvolvedores da plataforma Ubuntu está sempre disposta a auxiliar seus pares a iniciar.

en: Ubuntu is also a community of great people who believe in free software and that it should be accessible for everyone. Its members are welcoming and want you to be involved as well. We want you to get involved, to ask questions, to make Ubuntu better together with us.
pt_BR: O Ubuntu também é uma comunidade de boas pessoas que acreditam no software livre e que este deve estar acessível a todos. Seus membro são amistosos  e querem que você se envolva também. Queremos que você se envolva, faça perguntas, para fazer o Ubuntu melhor junto conosco.

en: If you run into problems: don't panic! Check out the :doc:`communication article<./communication>` and you will find out how to most easily get in touch with other developers.
pt_BR: Se você encontrar problemas, não entre em pânico! Confira o :doc:`artigo sobre comunicação<./communication>` e você irá descobrir a maneira mais fácil de entrar em contato com outros desenvolvedores.

en: The guide is split up into two sections:
pt_BR: O guia é dividido em duas seções:

en: A list of articles based on tasks, things you want to get done.
pt_BR: Um lista de artigos baseada em tarefas, coisas que você quer fazer.

en: A set of knowledge-base articles that dig deeper into specific bits of our tools and workflows.
pt_BR: Um conjunto de artigos de base de conhecimento que se aprofunda em partes específicas de nossas ferramentas e fluxos de trabalho.

en: Articles
pt_BR: Artigos

en: Knowledge Base
pt_BR: Base de conhecimento

en: Further Reading
pt_BR: Leitura adicional

en: Introduction to Ubuntu Development
pt_BR: Introdução ao desenvolvimento Ubuntu

en: Another important tool regarding communication is bug reports. Whenever a defect is found in a package or piece of infrastructure, a bug report is filed in Launchpad. All information is collected in that report and its importance, status and assignee updated when necessary. This makes it an effective tool to stay on top of bugs in a package or project and organise the workload.
pt_BR: Uma outra importante ferramenta de comunicação são os relatórios de erros. Sempre que um defeito é encontrado em um pacote ou parte da infraestrutura, um relatório de erro deve ser registrado no Launchpad. Todas as informações são coletadas nesse relatório, a sua importância, o status e atualização de para quem foi atribuído, quando necessário. Isto faz com que seja uma ferramenta efetiva para ficar em cima dos erros em um pacote ou projeto e organizar a carga de trabalho.

en: Getting a change into Ubuntu as a new contributor is not as daunting as it seems and can be a very rewarding experience. It is not only about learning something new and exciting, but also about sharing the solution and solving a problem for millions of users out there.
pt_BR: Ser um novo colaborador do Ubuntu não é tão intimidador como parece e pode ser uma experiência bastante compensadora. Não é apenas aprender algo novo e excitante, mas também sobre compartilhar a solução e resolver um problema para milhões de usuários.

en: In the example mentioned above it would make sense to ship Ubuntu with the existing version of the project, add the bugfix, get it into Upstream for their next release and ship that (if suitable) in the next Ubuntu release. It would be the best possible compromise and a situation where everybody wins.
pt_BR: No exemplo mencionado acima faria sentido incluir a versão existente do projeto no Ubuntu, adicionar uma correção de erro, colocá-lo no upstream para o seu próximo lançamento (se for possível) e inclui-lo na próxima versão do Ubuntu. Seria a melhor solução, uma situação onde todos saem ganhando.

en: When trying to find a solution it is usually a good idea to check with Upstream and see if the problem (or a possible solution) is known already and, if not, do your best to make the solution a concerted effort.
pt_BR: Quando estiver tentando encontrar uma solução, normalmente é uma boa ideia verificar como o uspstream se o problema (ou uma possível solução) já é conhecida e, se não, fazer de tudo para que a solução seja um esforço coordenado.

en: Additional steps might involve getting the change backported to an older, still supported version of Ubuntu and forwarding it to Upstream.
pt_BR: Passos adicionais podem envolver fazer o backport da alteração para uma versão mais velha ainda suportada ou repassá-la ao upstream.

en: The most important requirements for success in Ubuntu development are: having a knack for "making things work again," not being afraid to read documentation and ask questions, being a team player and enjoying some detective work.
pt_BR: Os requisitos mais importantes para o sucesso no desenvolvimento do Ubuntu são: ter a habilidade de "fazer as coisas voltarem a funcionar", não ter medo de ler documentação e fazer perguntas, jogar em equipe e gostar de trabalhar como detetive.

en: KDE Packaging
pt_BR: Empacotamento do KDE

en: Patching Policy
pt_BR: Politica de patches

en: Kubuntu does not add patches to KDE programs unless they come from the upstream authors or submitted upstream with the expectation they will be merged soon or we have consulted the issue with the upstream authors.
pt_BR: O Kubuntu não adiciona patches aos programas do KDE a menos que venham dos autores do upstream ou submetidos ao upstream com a expectativa de que sejam mesclados logo ou que tenhamos consultado a questão com os autores upstream.

en: Kubuntu does not change the branding of packages except where upstream expects this (such as the top left logo of the Kickoff menu) or to simplify (such as removing splash screens).
pt_BR: O Kubuntu não altera o nome dos pacotes exceto quando o upstream o requer (como o logo no canto superior esquerdo do menu Kickoff) ou para simplificar (como remover telas de inicialização).

en: Debian packages include some additions to the basic Debhelper usage. These are kept in the ``pkg-kde-tools`` package.
pt_BR: Os pacotes do Debian incluem algumas adições ao uso básico do Debhelper. Elas ficam no pacote "pkg-kde-tools".

en: Packages which use Debhelper 7 should add the ``--with=kde`` option. This will ensure the correct build flags are used and add options such as handling kdeinit stubs and translations::
pt_BR: Pacotes que usam o Debhelper 7 devem adicionar a opção "--with=kde". Isto irá assegurar que os sinalizadores de construção corretos estão sendo usados e adicionar opções como manuseio de stubs do kdeinit e traduções::

en: Some newer KDE packages use the ``dhmk`` system, an alternative to ``dh`` made by the Debian Qt/KDE team.  You can read about it in /usr/share/pkg-kde-tools/qt-kde-team/2/README.  Packages using this will ``include /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` instead of running ``dh``.
pt_BR: Alguns pacotes KDE mais novos usam o sistema "dhmk", uma alternativa ao "dh" feito pelo time do Debian Qt/KDE. Você pode ler sobre ele em /usr/share/pkg-kde-tools/qt-kde-team/2/README. Pacotes que o utilizam irão "incluir /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk" em vez de executar "dh".

en: Translations
pt_BR: Traduções

en: Packages in main have their translations imported into Launchpad and exported from Launchpad into Ubuntu's language-packs.
pt_BR: Os pacotes do main tem as suas traduções importadas no Launchpad e exportadas do Launchpad para o os pacotes de idioma do Ubuntu.

en: So any KDE package in main must generate translation templates, include or make available upstream translations and handle ``.desktop`` file translations.
pt_BR: Então todos os pacotes KDE devem gerar modelos de tradução, incluir ou deixar disponível traduções upstream e manipular traduções de arquivos ".desktop".

en: To generate translation templates the package must include a ``Messages.sh`` file; complain to the upstream if it does not.  You can check it works by running ``extract-messages.sh`` which should produce one or more ``.pot`` files in ``po/``.  This will be done automatically during build if you use the ``--with=kde`` option to ``dh``.
pt_BR: Para gerar modelos de tradução o pacote precisa incluir um arquivo "Messages.sh". Reclame ao upstream caso isto não aconteça. Você pode verificar se ele funciona executando "extract-messages.sh" que deve produzir um ou mais arquivos ".pot" em "po/". Isto será feito automaticamente durante a construção se você usar a opção "--with=kde" para "dh".

en: If a package is moved from universe to main it will need to be re-uploaded before the translations get imported into Launchpad.
pt_BR: Se um pacote é movido de "universe" para "main", ele precisará ser reenviado antes que as traduções sejam importadas para o Launchpad.

en: Library Symbols
pt_BR: Símbolos de bibliotecas

en: Shared Libraries
pt_BR: Bibliotecas compartilhadas

en: Shared libraries are compiled code which is intended to be shared among several different programs.  They are distributed as ``.so`` files in ``/usr/lib/``.
pt_BR: Bibliotecas compartilhadas são códigos compilados para serem compartilhados entre diversos programas diferentes. Eles são distribuídos como arquivos ".so" em "/usr/lib/".

en: A library exports symbols which are the compiled versions of functions, classes and variables.  A library has a name called an SONAME which includes a version number.  This SONAME version does not necessarily match the public release version number.  A program gets compiled against a given SONAME version of the library.  If any of the symbols is removed or changes then the version number needs to be changed which forces any packages using that library to be recompiled against the new version.  Version numbers are usually set by upstream and we follow them in our binary package names called an ABI number, but sometimes upstreams do not use sensible version numbers and packagers have to keep separate version numbers.
pt_BR: Uma biblioteca exporta símbolos que são versões compiladas de funções, classes e variáveis. Uma biblioteca tem nome chamado de SONAME que inclui o número de versão. Esta versão SONAME não corresponde necessariamente ao número de versão de lançamento público. Um programa é compilado com uma versão SONAME da biblioteca. Se qualquer dos símbolos for removido ou alterado, então o número da versão precisa ser alterado, o que força todos os pacotes que usam aquela biblioteca a serem recompilados com a nova versão. A numeração de versão é geralmente definida pelo uspstream e nós a seguimos em nossos nomes de pacotes binários chamados numeração ABI. Mas às vezes o upstream não utiliza uma numeração de versão prática e os empacotadores têm que manter uma numeração de versão separada.

en: Libraries are usually distributed by upstream as standalone releases. Sometimes they are distributed as part of a program.  In this case they can be included in the binary package along with the program (this is called bundling) if you do not expect any other programs to use the library, more often they should be split out into separate binary packages.
pt_BR: As bibliotecas são normalmente distribuídas pelo upstream como versões independentes. Às vezes elas são distribuídas como parte de um programa. Neste caso elas podem ser incluídas no pacote binário junto com o programa se você não espera que outros programas utilizem a biblioteca. Geralmente, elas devem ser divididas em pacotes binários separados.

en: The libraries themselves are put into a binary package named ``libfoo1`` where ``foo`` is the name of the library and ``1`` is the version from the SONAME. Development files from the package, such as header files, needed to compile programs against the library are put into a package called ``libfoo-dev``.
pt_BR: As bibliotecas em si são colocadas em um pacote binário chamado "libfoo1" onde "foo" é o nome da biblioteca e "1" é a versão do SONAME. Arquivos de desenvolvimento do pacote, como os arquivos de cabeçalhos, necessários para compilar programas com a biblioteca, serão colocados em um pacote chamado "libfoo-dev".

en: An Example
pt_BR: Um exemplo

en: We will use libnova as an example::
pt_BR: Vamos usar libnova como um exemplo::

en: To find the SONAME of the library run::
pt_BR: Para encontra o SONAME de uma biblioteca, execute::

en: The SONAME is ``libnova-0.12.so.2``, which matches the file name (usually the case but not always). Here upstream has put the upstream version number as part of the SONAME and given it an ABI version of ``2``.  Library package names should follow the SONAME of the library they contain. The library binary package is called ``libnova-0.12-2`` where ``libnova-0.12`` is the name of the library and ``2`` is our ABI number.
pt_BR: O SONAME é "libnova-0.12.so.2", que corresponde ao nome do arquivo (geralmente é o caso, mas nem sempre). Aqui o upstream colocou o número da versão upstream como parte do SONAME e deu a ele a versão ABI "2". Nomes de pacotes de bibliotecas devem seguir de acordo como SONAME das bibliotecas que contêm. O pacote binário de biblioteca "libnova-0.12-2" onde "libnova-0.12" é o nome da biblioteca e "2" é o nosso número ABI.

en: If upstream makes incompatible changes to their library they will have to reversion their SONAME and we will have to rename our library.  Any other packages using our library package will need to recompiled against the new version, this is called a transition and can take some effort. Hopefully our ABI number will continue to match upstream's SONAME but sometimes they introduce incompatibilities without changing their version number and we will need to change ours.
pt_BR: Se o upstream fizer alterações incompatíveis às suas bibliotecas, eles terão que reversionar o SONAME e nós teremos que renomear nossa biblioteca. Quaisquer outros pacotes usando o nosso pacote de biblioteca terão que ser recompilados com a nova versão, o que é chamado "transição" e pode exigir algum trabalho. Com sorte, nosso número ABI continuará a corresponder ao SONAME do uspstream, mas algumas vezes eles introduzem incompatibilidades sem alterar o seu número de versão e nós teremos que alterar o nosso.

en: Looking in debian/libnova-0.12-2.install we see it includes two files::
pt_BR: Olhando em debian/libnova-0.12-2.install, vemos que inclui dos arquivos::

en: The last one is the actual library, complete with minor and point version number.  The first one is a symlink which points to the actual library.  The symlink is what programs using the library will look for, the running programs do not care about the minor version number.
pt_BR: A última é a biblioteca real, completa com numeração de versão. A primeira é um link simbólico que aponta para a verdadeira biblioteca. O link simbólico é o que os programas que utilizam a biblioteca irão procurar, os programas em execução não se importam com alterações de versão menores.

en: Static Libraries
pt_BR: Bibliotecas estáticas

en: Symbol Files
pt_BR: Arquivos de símbolos

en: To make the library dependencies more precise we keep ``.symbols`` files that list all the symbols in a library and the version they appeared in.
pt_BR: Para fazer as dependências de uma biblioteca mais precisas, nós mantemos os arquivos ".symbols" que listam todos os símbolos em uma biblioteca e a versão em que eles aparecem.

en: libnova has no symbols file so we can create one.  Start by compiling the package::
pt_BR: libnova não tem arquivo de símbolos, então podemos criar um. Inicie compilando o pacote::

en: The ``-nc`` will cause it to finish at the end of compilation without removing the built files.  Change to the build and run ``dpkg-gensymbols`` for the library package::
pt_BR: O "-nc" irá fazer terminar no final da compilação sem remover os arquivos de compilação. Vá para o diretório de compilação e execute "dpkg-gensymbols" para o pacote de biblioteca::

en: This makes a diff file which you can self apply::
pt_BR: Isto gera um arquivo diff que você pode auto-aplicar::

en: Now move the file into its location, commit and do a test build::
pt_BR: Agora mova o arquivo para a seu novo local, submeta e faça uma construção de teste::

en: If it successfully compiles the symbols file is correct.  With the next upstream version of libnova you would run dpkg-gensymbols again and it will give a diff to update the symbols file.
pt_BR: Se a compilação for bem-sucedida, o arquivo de símbolos está correto. Com a próxima versão usptream do libnova, se você executar dpkg-gensymbols novamente ele irá gerar um diff para atualizar o arquivo de símbolos.

en: C++ Library Symbols Files
pt_BR: Arquivos de símbolos de bibliotecas C++

en: Packaging New Software
pt_BR: Empacotando um novo software

en: While there are thousands of packages in the Ubuntu archive, there are still a lot nobody has gotten to yet. If there is an exciting new piece of software that you feel needs wider exposure, maybe you want to try your hand at creating a package for Ubuntu or a PPA_. This guide will take you through the steps of packaging new software.
pt_BR: Mesmo que haja milhares de pacotes no arquivo do Ubuntu, ainda há os que ninguém pegou ainda. Se houver um programa que você acha que deva ganhar uma exposição maior, talvez você queira colocar a mão na massa e criar um pacote para o Ubuntu ou um PPA_. Este guia irá mostrar passo-a-passo o processo de empacotamento e um novo programa.

en: You will want to read the :doc:`Getting Set Up<./getting-set-up>` article first in order to prepare your development environment.
pt_BR: Você deverá ler o artigo :doc:`Preparando<./getting-set-up>` para preparar o seu ambiente de desenvolvimento.

en: Checking the Program
pt_BR: Verificando o programa

en: The first stage in packaging is to get the released tar from upstream (we call the authors of applications "upstream") and check that it compiles and runs.
pt_BR: O primeiro estágio no empacotamento é obter o tar da versão a partir do upstream (nós chamamos os autores dos aplicativos de "upstream") e verificar se ele compila e executa.

en: This guide will take you through packaging a simple application called GNU Hello which has been posted on GNU.org_.
pt_BR: Este guia irá mostrar como empacotar um aplicativo simples chamado GNU Hello que foi postado em GNU.org_.

en: This application uses the autoconf build system so we want to run ``./configure`` to prepare for compilation.
pt_BR: Este aplicativo utiliza um sistema de compilação de autoconfiguração, então nós devemos executar "./configure" para preparar para a compilação.

en: Now you can compile the source::
pt_BR: Agora você pode compilar o fonte::

en: If compilation completes successfully you can install and run the program::
pt_BR: Se a compilação concluir com sucesso você poderá instalar e executar o programa::

en: Starting a Package
pt_BR: Iniciando um pacote

en: When it asks what type of package type ``s`` for single binary. This will import the code into a branch and add the ``debian/`` packaging directory.  Have a look at the contents.  Most of the files it adds are only needed for specialist packages (such as Emacs modules) so you can start by removing the optional example files::
pt_BR: Quando for perguntado o tipo de pacote, digite "s" para um único binário. Isto irá importar o código para um ramo e adicionar o diretório de empacotamento "debian/". Dê uma olhada no conteúdo. A maioria dos arquivos adicionados são necessários somente para pacotes especializados (como módulos Emacs), então você pode começar removendo os arquivos de exemplo opcionais::

en: You should now customise each of the files.
pt_BR: Agora você deve customizar cada um dos arquivos.

en: You will also need to fill in a description of the program in the ``Description:`` field.
pt_BR: Você também precisará preencher a descrição do programa no campo "Description:".

en: ``copyright`` needs to be filled in to follow the licence of the upstream source.  According to the hello/COPYING file this is GNU GPL 3 or later.
pt_BR: "copyright" deve ser preenchido de acordo com a licença do código upstream. De acordo com o arquivo hello/COPYING, ela é GNU GPL 3 ou mais recente.

en: ``docs`` contains any upstream documentation files you think should be included in the final package.
pt_BR: "docs" contém todos os arquivos de documentação do upstream que você acha que devam ser incluídos no pacote final.

en: ``README.source`` and ``README.Debian`` are only needed if your package has any non-standard features, we don't so you can delete them.
pt_BR: "README.source" e "README.Debian" são necessários somente se o seu pacote tiver quaisquer características fora do padrão. Nós não temos, você pode excluí-los.

en: ``source/format`` can be left as is, this describes the version format of the source package and should be ``3.0 (quilt)``.
pt_BR: "source/format" pode ser deixado como está, ele descreve o formato da versão do pacote fonte e deve ser "3.0 (quilt)".

en: ``rules`` is the most complex file.  This is a Makefile which compiles the code and turns it into a binary package.  Fortunately most of the work is automatically done these days by ``debhelper 7`` so the universal ``%`` Makefile target just runs the ``dh`` script which will run everything needed.
pt_BR: O "rules" é o arquivo mais complexo. É um makefile que compila o código e o transforma em um pacote binário. Felizmente, a maior parte do trabalho hoje em dia é feita automaticamente pelo "debhelper 7" para que o alvo makefile universal "%" apenas execute o script "dh", que irá executar tudo que for necessário.

en: All of these file are explained in more detail in the :doc:`overview of the debian directory<./debian-dir-overview>` article.
pt_BR: Todos estes arquivos são explicados mais detalhadamente no artigo :doc:`resumo do diretório debian<./debian-dir-overview>`.

en: Finally commit the code to your packaging branch::
pt_BR: Finalmente submeta o código para seu ramo de empacotamento::

en: Building the package
pt_BR: Construindo o pacote

en: Now we need to check that our packaging successfully compiles the package and builds the .deb binary package::
pt_BR: Agora precisamos verificar se nosso empacotamento compila o pacote com sucesso e constrói o pacote binário .deb::

en: ``bzr builddeb`` is a command to build the package in its current location. The ``-us -uc`` tell it there is no need to GPG sign the package.  The result will be placed in ``..``.
pt_BR: "bzr builddeb" é um comando para construir o pacote no local atual. As opções "-us -uc" dizem que não é preciso que o GPG assine o pacote. O resultado será colocado em "..".

en: You can view the contents of the package with::
pt_BR: Você pode visualizar o conteúdo do pacote com::

en: Next Steps
pt_BR: Próximos passos

en: After making a fix to the packaging you can rebuild using ``-nc`` "no clean" without having to build from scratch::
pt_BR: Depois de efetuar uma correção no empacotamento, você pode reconstruí-lo usando "-nc" (no clean) não precisando construir tudo novamente::

en: When you are happy with your package you will want others to review it.  You can upload the branch to Launchpad for review::
pt_BR: Quando você estiver feliz com seu pacote você irá querer que outros revisem-o. Você pode enviar para o ramo no Launchpad para revisão::

en: Uploading it to a PPA will ensure it builds and give an easy way for you and others to test the binary packages.  You will need to set up a PPA in Launchpad and then upload with ``dput``::
pt_BR: Enviá-lo ao PPA irá assegurar que ele pode ser construído e irá fornecer uma maneira fácil para você e os outros testarem os pacotes binários. Você deverá configurá um PPA no Launchpad e então enviar o pacote com "dput"::

en: Submitting for inclusion
pt_BR: Submetendo para inclusão

en: There are a number of paths that a package can take to enter Ubuntu. In most cases, going through Debian first can be the best path. This way ensures that your package will reach the largest number of users as it will be available in not just Debian and Ubuntu but all of their derivatives as well. Here are some useful links for submitting new packages to Debian:
pt_BR: Há várias maneira pelas quais um pacote pode entrar no Ubuntu. Na maioria dos casos, ir através do Debian primeiro pode ser a melhor maneira. Isto assegurará que o seu pacote alcançará o maior número de usuários, porque estará disponível não somente no Debian e no Ubuntu, mas também em todas as distribuições derivadas. Aqui estão alguns links úteis para enviar novos pacotes para o Debian:

en: Patches to Packages
pt_BR: Patches para pacotes

en: There are a number of different ways of handling patches in Debian packages, fortunately we are standardizing on one system, `Quilt`_, which is now used by most packages.
pt_BR: Há várias maneiras diferentes de lidar com patches em pacotes Debian, felizmente estamos padronizando um sistema, `Quilt`_, que agora é utilizado pela maioria dos pacotes.

en: The order of patches to apply is kept in ``debian/patches/series``.
pt_BR: A ordem dos patches para aplicar é mantida em ``debian/patches/series``.

en: Patches with Quilt
pt_BR: Patches com o Quilt

en: Before working with Quilt you need to tell it where to find the patches.  Add this to your ``~/.bashrc``::
pt_BR: Antes de trabalhar com o Quilt você precisa informar a ele onde encontrar os patches. Adicione isso em seu "~/.bashrc"::

en: And source the file to apply the new export::
pt_BR: E forneça a origem do arquivo para aplicar a nova exportação::

en: By default all patches are applied already to UDD checkouts or downloaded packages.  You can check this with::
pt_BR: Por padrão, todos os patches são aplicados diretamente nos checkouts de UDD ou pacotes baixados. Você pode verificar isto com::

en: If you wanted to remove the patch you would run ``pop``::
pt_BR: Se você quisesse remover o patch poderia executar ``pop``::

en: And to apply a patch you use ``push``::
pt_BR: E para aplicar um patch você usa ``push``::

en: Adding a New Patch
pt_BR: Adicionando um novo patch

en: To add a new patch you need to tell Quilt to create a new patch, tell it which files that patch should change, edit the files then refresh the patch::
pt_BR: Para adicionar um novo patch você deve dizer ao Quilt para criar um novo patch, dizer a ele quais arquivos o patch irá alterar, editar os arquivos e então atualizar o patch::

en: The ``quilt add`` step is important, if you forget it the files will not end up in the patch.
pt_BR: O passo ``quilt add`` é importante, se você esquecê-lo os arquivos não vão terminar no patch.

en: The change will now be in ``debian/patches/kubuntu_02_program_description.diff`` and the ``series`` file will have had the new patch added to it.  You should add the new file to the packaging::
pt_BR: A mudança agora estará em ``debian/patches/kubuntu_02_program_description.diff`` e o arquivo ``series`` terá um novo patch adicionado a ele. Você deve adicionar o novo arquivo para o empacotamento::

en: Quilt keeps its metadata in the ``.pc/`` directory, so currently you need to add that to the packaging too.  This should be improved in future.
pt_BR: O Quilt mantém os seus metadados no diretório ".pc/", então atualmente você precisa adicioná-lo ao empacotamento também. Isto deverá ser aprimorado no futuro.

en: Upgrading to New Upstream Versions
pt_BR: Atualizando para novas versões do upstream

en: If it can be reverse-applied this means the patch has been applied already by upstream, so we can delete the patch::
pt_BR: Se a aplicação puder ser revertida, isto significa que o patch já foi aplicado pelo upstream, então podemos excluir o patch::

en: Then carry on::
pt_BR: Então continue::

en: It is a good idea to run refresh, this will update the patch relative to the changed upstream source::
pt_BR: É bom executar uma atualização do patch relativo ao fonte do upstream alterado::

en: Then commit as usual::
pt_BR: Então submeta como sempre::

en: Making A Package Use Quilt
pt_BR: Fazendo um pacote usar o Quilt

en: Modern packages use Quilt by default, it is built into the packaging format.  Check in ``debian/source/format`` to ensure it says ``3.0 (quilt)``.
pt_BR: Pacotes modernos usam o Quilt por padrão, que é construído dentro do formato do pacote.  Verifique ``debian/source/format`` para assegurar que ele diz ``3.0 (quilt)``.

en: Older packages using source format 1.0 will need to explicitly use Quilt, usually by including a makefile into ``debian/rules``.
pt_BR: Pacotes antigos usando o formato de fonte 1.0 terão que explicitar o uso do Quilt, normalmente incluindo um makefile dentro de ``debian/rules``.

en: Other Patch Systems
pt_BR: Outros sistemas de patch

en: Do not change a package's patch system without discussing it with the Debian maintainer or relevant Ubuntu team.  If there is no existing patch system then feel free to add Quilt.
pt_BR: Não altere um sistema de patches de um pacote sem discutir isto com o mantenedor Debian ou time Ubuntu responsável. Se não houver sistema de patches, então sinta-se à vontade para adicionar o Quilt.

en: Security and Stable Release Updates
pt_BR: Atualizações de segurança de versão estável

en: Fixing a Security Bug in Ubuntu
pt_BR: Corrigindo uma falha de segurança no Ubuntu

en: Obtaining the source
pt_BR: Obtendo o fonte

en: Patching the source
pt_BR: Aplicando um patch no código fonte

en: To create your patch using ``edit-patch``::
pt_BR: Para criar seu patch usando ``edit-patch``::

en: This will apply the existing patches and put the packaging in a temporary directory. Now edit the files needed to fix the vulnerability.  Often upstream will have provided a patch so you can apply that patch::
pt_BR: Isto irá aplicar os patches existentes e colocar o pacote em um diretório temporário. Agora edite os arquivos necessários para corrigir a vulnerabilidade. Frequentemente, o upstream terá fornecido um patch, então você pode aplicá-lo::

en: After making the necessary changes, you just hit Ctrl-D or type exit to leave the temporary shell.
pt_BR: Depois de fazer as mudanças necessárias, é só pressionar Ctrl-D ou digitar "exit" para sair temporariamente do shell.

en: Formatting the changelog and patches
pt_BR: Formatando o registro de alteração e os patches

en: Update your patch to use the appropriate patch tags. Your patch should have at a minimum the Origin, Description and Bug-Ubuntu tags. For example, edit debian/patches/99-fix-a-vulnerability.patch to have something like::
pt_BR: Atualize o seu patch para que use tags apropriadas. Seu patch deve ter no mínimo a orígem, descrição e tags bug-Ubuntu. Por exemplo, edite debian/patches/99-fix-a-vulnerability.patch para ter algo como::

en: Multiple vulnerabilities can be fixed in the same security upload; just be sure to use different patches for different vulnerabilities.
pt_BR: Várias vulnerabilidades podem ser corrigidas no mesmo envio de segurança; apenas certifique-se de usar patches diferentes para vulnerabilidades diferentes.

en: Test and Submit your work
pt_BR: Testar e enviar o seu trabalho

en: At this point the process is the same as for :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`. Specifically, you will want to:
pt_BR: Neste ponto, o processo é o mesmo que para :doc:`corrigir um erro comum no Ubuntu<./fixing-a-bug>`. Especificamente, você deve:

en: Build your package and verify that it compiles without error and without any added compiler warnings
pt_BR: Construir seu pacote e verificar se compilou sem erros e sem quaisquer avisos de compilador

en: Upgrade to the new version of the package from the previous version
pt_BR: Atualizar para a nova versão do pacote de uma versão anterior

en: Test that the new package fixes the vulnerability and does not introduce any regressions
pt_BR: Verifique se o novo pacotes corrige a vulnerabilidade e não introduz nenhuma regressão

en: Submit your work via a Launchpad merge proposal and file a Launchpad bug being sure to mark the bug as a security bug and to subscribe ``ubuntu-security-sponsors``
pt_BR: Envie seu trabalho via proposta de mesclagem do Launchpad, registre um erro no Launchpad assegurando-se de marcar o erro como erro de segurança e inscreva-se no "ubuntu-security-sponsors".

en: If the security vulnerability is not yet public then do not file a merge proposal and ensure you mark the bug as private.
pt_BR: Se a vulnerabilidade de segurança não é pública ainda então não adicione a proposta de mesclagem e certifique-se de que você marcou a falha como privada.

en: Stable Release Updates
pt_BR: Atualizações de versão estável

en: The process for Stable Release Updates is just the same as the process for security bugs except you should subscribe ``ubuntu-sru`` to the bug.
pt_BR: O processo para atualizações de versões estáveis é o mesmo que o processo para falhas de seguranção, exceto que você deve registrar "ubuntu-sru" no relatório de erro.
