Entendo que o Ubuntu honra a "liberdade de modificar o software", mas como alguém deve modificar o código-fonte dos pacotes do Ubuntu sem quebrar o sistema? Ao quebrá-lo, quero dizer, por exemplo, criar dependências insolúveis ou bloquear apt updateatualizações futuras, especialmente atualizações de segurança.
Existe uma maneira de salvar um "patch" de modificações e aplicá-lo a futuras atualizações do apt? Prefiro evitar "bifurcar" um pacote completamente.
É algo para o qual serve o "apt pinning"? Ou o "modelo de estabilidade" do Ubuntu (não tenho certeza se esse é o termo correto) simplesmente não suporta modificações do usuário? Eu ficaria grato por uma dica se outras distribuições lidarem com isso de maneira diferente (Arch/Gentoo).
Como isso funciona em geral é que os mantenedores de pacotes de uma distribuição pegam as fontes originais da fonte oficial (GitHub, SourceForge etc.; o código upstream ) que geralmente vem como um tarball (um arquivo tar compactado). E esses permanecem como estão; intocado como é chamado.
Mas normalmente algumas adaptações precisam ser feitas para que tudo funcione bem em conjunto com a distribuição geral. Portanto, o mantenedor do pacote descompacta essas fontes originais em um diretório de trabalho e altera a fonte conforme necessário; e então usa o
diffcomando para gerar o conjunto de alterações, ou seja, os poucos lugares que foram realmente alterados entre a versão original e a agora modificada ("corrigida").Este conjunto de mudanças é chamado de diff ou patch . Para cada pacote, pode haver um deles ou vários; normalmente eles são organizados por tópico; ou seja, um para caminhos diferentes na distribuição de destino, outro para contornar peculiaridades de outro programa chamado por este software, etc.; Você entendeu a ideia.
Esse tarball original e os diffs/patches são colocados em outro arquivo (um pacote fonte ), mas mantidos separados o suficiente para que tudo permaneça transparente.
Quando o pacote é construído , isso significa que primeiro o tarball original é descompactado, então o primeiro patch é aplicado (usando o
patchprograma), então o segundo etc.; e quando esse estágio de correção estiver concluído, o processo de compilação será realmente iniciado (chamadasmakeemake installo que mais for necessário).Isso é feito em todas as distribuições Linux que conheço; Ubuntu, Debian, SUSE, Red Hat, você escolhe. Provavelmente é o mesmo para todos, e provavelmente também para variantes BSD.
Portanto, existem os pacotes de origem ; e é aqui que você entra. Nada o impede de pegar um pacote fonte e adicionar outro patch ou dois em cima dele; e gere seu próprio pacote fonte com base nisso.
A ressalva é que agora você mesmo terá que reconstruir o pacote; e certifique-se de adicionar seus patches a uma nova versão do pacote fonte sempre que um novo for lançado, ou seja, para cada atualização de pacote.
Isso pode ser feito, mas é tedioso. As chances são de que você fique sem motivação para fazer isso o tempo todo; dependendo de quantas vezes o pacote realmente muda.
Uma ferramenta para aliviar a dor é o openSUSE Build System (OBS) que suporta a automação de pelo menos parte dele. Mas você ainda precisa reimportar os pacotes de origem e adicionar seus próprios patches. Está disponível gratuitamente na web e pode criar pacotes para várias distribuições, incluindo não apenas openSUSE, mas também Ubuntu, Debian e outras.
Portanto, se você tiver uma alteração que seja de interesse geral, convém abordar os mantenedores do pacote de sua distribuição se eles não quiserem incluir suas alterações no pacote fonte. Ou você pode entrar em contato com os autores originais (aqueles que escreveram o software originalmente) se eles não quiserem publicar suas alterações para todos.
Se for algo muito específico para o seu caso de uso, obviamente não vai funcionar. Nesse caso, pense em uma estratégia diferente.