Introdução

Trabalho

Este trabalho é o projeto final da disciplina de Gerência de Configuração de Software da Universidade de Brasília, no qual visa realizar contribuições relacionadas a gerência de configuração em projetos open source a fim de fixar e colocar em prática os conceitos aprendidos em sala de aula.

Informações e outros projetos relacionados a disciplina estão disponíveis na página da Wikiversity da disciplina.

A ementa da disciplina está disponível aqui.

Para saber mais sobre a área de Gerência de Configuração de Software, ver a página da Wikipédia.

Projeto

FGAme é uma engine de jogos 2d desenvolvida em python. Com foco na facilidade de utilização e não na performance da mesma.

É bastante versátil no quesito física clássica e bastante limitada no quesito gráficos, sendo a mesma utilizada na disciplina de Física para Jogos da UnB/FGA com o intuito de ensinar aos alunos os conceitos de física aplicados em jogos eletrônicos.

Objetivos

Devido a FGAme utilizar várias dependências, o foco desse trabalho é definir um ambiente padrão de desenvolvimento, garantindo que nenhuma atualização das dependências ou utilização de versões anteriores quebre o funcionamento adequado da engine.

Também será mostrado o passo a passo de como essa padronização foi realizada, gerando assim espaço para fechar certas versões da FGAme e assim podendo salvar e utilizar os trabalhos derivados da engine no futuro.

No geral, será feito:

Empacotamento Debian
Docker image

Cronograma

Período	Objetivo
26/09 a 02/10	Definição do projeto open source
03/09 a 09/10	Estudos sobre docker
10/10 a 16/10	Criação da docker image
17/10 a 23/10	Estudos sobre empacotamento Debian
24/10 a 30/10	Implementação do empacotamento Debian
31/10 a 06/11	Conclusão e Análise dos resultados
07/11 a 13/11	Criação da apresentação final e abrir o Pull-Request

Resultados

Empacotamento Debian

É uma maneira de distribuir software aos usuários, é bastante comum a utilização de pacotes .deb, devido a popularidade da distribuição Debian, juntamente com seus derivados, como Ubuntu e Linux Mint.

Para definir o ambiente nas distribuições Debian, colocaremos todas as dependências em um pacote .deb, facilitando assim a instalação nessas distribuições e possíveis incompatibilidades devido as versões das dependências.

O pygame é a principal depedência para o funcionamento da FGAme, decidi empacotar o mesmo com todas as dependências do pygame como depedências do pacote, sendo que os procedimentos a seguir só valem para a versão específica do python3 instalado, que no meu caso é a versão 3.4.3 do Sistema Operacional Linux Mint 17.3 Rosa.

Para clonar o repositório do pygame, é necessário ter o mercurial instalado, caso não tenha, basta usar o comando apt-get.

sudo apt-get install mercurial

Após ter instalado o mercurial, clone o repositório:

hg clone https://bitbucket.org/pygame/pygame

Mude o nome do repositório para o padrão debian e entre na pasta:

mv pygame pygame-1.9
cd pygame-1.9

Dentro do repositório, é necessário criar um diretório chamado debian que contém vários arquivos referêntes ao pacote a ser criado, para criar esse diretório já com os arquivos criados, escreva:

dh_make -s --indep --createorig

Caso não tenha o dh-make, escreva:

sudo apt-get install dh-make

É necessário fazer alterações nos arquivos control e rules dentro da pasta debian, edite o arquivo control com as seguintes informações:

Source: pygame
Section: utils
Priority: optional
Maintainer: Gustavo Cavalcante <gustavo.cavalcante.oliveira@live.com>
Build-Depends: debhelper (>= 9), python3
Standards-Version: 3.9.4
X-Python3-Version: >= 3.4
Homepage: <https://github.com/fabiommendes/FGAme>

Package: pygame
Architecture: all
Depends: python3-dev, python3-numpy, libsdl-image1.2-dev, libsdl-mixer1.2-dev, libsdl-ttf2.0-dev, libsmpeg-dev, libsdl1.2-dev, libportmidi-dev, libswscale-dev, libavformat-dev, libavformat-dev, libfreetype6-dev
Description: A simple 2D game engine for Python
 FGAme is a physics-based game engine for Python 3. Its aims to avoid boilerplate and to be so easy that even a child can play with it (and learn how to program with it!).

Em seguida, edite o arquivo rules:

#!/usr/bin/make -f

DPKG_EXPORT_BUILDFLAGS = 1
include /usr/share/dpkg/default.mk
export PYBUILD_INSTALL_ARGS_python2 = --install-scripts=/dev/null
 
# main packaging script based on dh7 syntax
%:
	dh $@ --with python3 --buildsystem=pybuild

clean:
	# null

Finalmente, para criar o arquivo .deb, basta digitar:

DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -b -rfakeroot

Será criado um arquivo .deb no diretório acima ( ../ ).

Para empacotamento da própria FGAme, sofre o mesmo problema do pygame em relação a versão do python3, os procedimentos a seguir valem somente para a versão 3.4 do Python. Comece criando um diretório, utilizando o comando mkdir.

mkdir fgame (1)

Entre no diretório criado e em seguida crie as seguintes pastas:

mkdir DEBIAN (2)
mkdir usr/local/lib/python3.4/dist-packages/ (3)

Será necessário instalar a FGAme primeiramente com o comando:

sudo python3 -m pip install FGAme

Depois de instalada, copie as seguintes pastas do diretório /usr/local/lib/python3.4/dist-packages/

- FGAme
- FGAme-0.6.3.egg-info
- lazyutils
- lazyutils-0.3.2.egg-info
- pygeneric-0.5.4.egg-info
- smallshapes
- smallshapes-0.6.2.egg-info
- smallvectors
- smallvectors-0.6.3.egg-info
- typing-3.5.2.2.egg-info

para o diretório (3).

Após isso, crie um arquivo chamado control, dentro da pasta DEBIAN.

Cole as seguintes informações dentro do arquivo control.

Package: fgame
Version: 1.0
Architecture: all
Maintainer: Gustavo <gustavo.cavalcante.oliveira@live.com>
Depends: python3
Recommends: 
Homepage: https://github.com/fabiommendes/FGAme
Priority: optional
Description: A simple python physics engine.
Original-Maintainer: Gustavo <gustavo.cavalcante.oliveira@live.com>

Para finalizar, basta escrever o seguinte comando dentro do diretório (1).

dpkg-deb -b . .

Será criado um pacote debian dentro do diretório, tendo como referência o próprio diretório.

Sendo que a própria FGAme foi empacotada somente com fins didáticos, já que a mesma já está empacotada no pip e funcionando para todas as versões do Python 3 até o momento.

Docker

Resumindo, Docker é um programa que consegue isolar tudo que é necessário para que certos programas funcionem. Utilizando containers, permitindo que um programa sempre rode, independente da versão do sistema operacional. Tudo que é necessário é que o Docker esteja instalado.

Será feito uma docker image contendo tudo que é necessário para utilização da FGAme, caso usuários Debian ou de outras distribuições não queiram instalar essas dependências em suas máquinas ou desejem uma instalação mais simples. Para instalação do Docker, visite a página de documentação.

Com o docker instalado, basta criar uma pasta qualquer e um arquivo chamado Dockerfile.

touch fgame/Dockerfile

Edite o arquivo Dockerfile com as seguintes informações:

FROM ubuntu:14.04

RUN apt-get update

RUN apt-get -y install python3-pip

RUN apt-get -y install python3-pil

RUN python3 -m pip install FGAme

RUN apt-get -y install mercurial

RUN hg clone https://bitbucket.org/pygame/pygame

RUN apt-get update

RUN apt-get install -y python3-dev python3-numpy libsdl-image1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev libsmpeg-dev libsdl1.2-dev libportmidi-dev libswscale-dev libavformat-dev libavcodec-dev libfreetype6-dev

RUN python3 pygame/setup.py build

RUN python3 pygame/setup.py install

RUN pip3 install pgzero

COPY . /

RUN export uid=1000 gid=1000 && \
    mkdir -p /home/developer && \
    echo "developer:x:${uid}:${gid}:Developer,,,:/home/developer:/bin/bash" >> /etc/passwd && \
    echo "developer:x:${uid}:" >> /etc/group && \
    echo "developer ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/developer && \
    chmod 0440 /etc/sudoers.d/developer && \
    chown ${uid}:${gid} -R /home/developer

USER developer
ENV HOME /home/developer
ENV SDL_VIDEODRIVER x11
ENV PULSE_SERVER unix:/home/developer/socket

ADD . /code
WORKDIR /code

RUN echo $PWD

CMD python3

Após isso, basta criar a imagem docker.

cd fgame
docker build -t fgame .

Antes de rodar a imagem em um container, escreva no terminal o comando abaixo para que o container consiga acessar o servidor de interface gráfica.

xhost +

Para rodar a imagem:

docker run --rm -ti -e DISPLAY=$DISPLAY -v /run/user/$UID/pulse/native:/home/developer/socket --name FGAme -v /tmp/.X11-unix:/tmp/.X11-unix fgame /bin/bash

Para verificar que tudo está funcionando corretamente, basta escrever o seguinte comando dentro do container Docker.

python3 test.py

A imagem Docker da FGAme se encontra no meu repositório, para mais detalhes de como subir uma imagem docker, clique aqui.

Para fazer o pull da imagem da FGAme, basta escrever no terminal:

docker pull gutioliveira/fgame

Para rodar a imagem, basta rodar o comando abaixo, lembrando sempre de rodar o comando 'xhost +' antes de iniciar o container.

docker run --rm -ti -e DISPLAY=$DISPLAY -v /run/user/$UID/pulse/native:/home/developer/socket --name FGAmex -v /tmp/.X11-unix:/tmp/.X11-unix  gutioliveira/fgame /bin/bash

Conclusões

Empacotamento Debian

Quando foi proposto o empacotamento Debian da FGAme, pensava-se que era possível colocar todas as dependências dentro do mesmo pacote e então fazer uma build das dependências em tempo de instalação, gerando assim uma build compatível com as versões do Python de cada usuário. O que não é o caso, pois a build é feita de acordo com o sistema operacional que está empacotando, gerando assim um pacote debian que só funcione na versão 3.4 do Python.

Como não foi possível fazer um empacotamento Debian que funcione em todas as versões do Python suportadas pela FGAme, decidi não abrir um Pull-Request com um arquivo .deb que seja tão restrito.

Como contra proposta de contribuição ao projeto, foi feito um guia de como instalar corretamente a FGAme nas distribuições Debian e seus derivados, já que no repositório do projeto, não existe nenhum guia de como instalar as dependências necessárias para utilização da engine.

Docker

Foi concluído com sucesso e o Pull-Request já foi aceito, tive problemas no início para conseguir renderizar uma janela dentro do container Docker. Algo que foi resolvido mapeando a localização do servidor X11 da máquina que está rodando o container com a localização do servidor X11 dentro do container. Um processo semelhante foi feito com relação ao áudio dentro do container.

Sobre o processo de criação da imagem, nada complicado, bastou-se utilizar a imagem oficial do Ubuntu 14.04 e instalar todas as dependências da FGAme. Com a imagem feita, a mesma foi colocada no Docker Hub e bastou-se alterar o arquivo de instalação da FGAme dentro do repositório com as instruções de como utiliza-la dentro de um container Docker.

Referências

Manual de empacotamento Debian

Documentação Docker

Docker - Acesso em 02/10/2016

Repositório oficial FGAme

Fork pessoal onde foi realizado o trabalho de GCS.