Ejudge.
Alunos:
Dandara Pereira Aranha - 110010256
João Henrique Pereira - 150132042
Introdução
editarVisão Geral
editarO Ejudge é um projeto criado e mantido pelo professor Edson Alves da Universidade de Brasília. Ele é composto por sete ferramentas para a automação de provas e competições de programação. Essas ferramentas são:
- checker: script para a correção automática das soluções propostas;
- client: programa para o envio de soluções ao servidor;
- core: biblioteca estática com funcionalidades comuns;
- problems: scripts para a formatação e instalação de problemas;
- scoreboard: programa que representa o placar da competição;
- server: servidor que recebe as soluções propostas via rede;
- users: scripts para o cadastro de usuários.
A documentação de cada um dos módulos se encontra nos respectios diretórios e o link para o repositório oficial pode ser encontrado no seguinte link: https://gitlab.com/ejudge/ejtools
O trabalho que será desenvolvido na disciplina de Gerência e Configuração de Software será focado no módulo scoreboard, e será também desenvolvido em conjunto com a disciplina de Manutenção e Evolução de Software.
Propósito
editarO propósito do Plano de Gerência de Configuração é descrever e documentar todas as atividades do Gerenciamento de Configuração, Controle e Mudanças que serão executadas durante o ciclo de vida do projeto. Possui também o cronograma de atividades, as responsabilidades atribuídas, e os recursos necessários, como ferramentas e computadores.
Escopo
editarAS demandas identificadas foram baseadas em pedidos do próprio mantenedor do projeto, o Professor Edson e também em necessidades identificadas pela aluna da disciplina de GCS. Entretanto elas podem ser modificadas até o fim do projeto:
- Integração Contínua com GitLab CI
- Configurar ambiente de desenvolvimento com o Vagrant
- Empacotar o módulo de scoreboard, com o intuito de facilitar a instalação do mesmo por usuários.
- Escrever testes para o módulo scoreboard do Ejudge. *
*Será desenvolvido no contexto da disciplina de Manutenção e Evolução de Software e reaproveitado nesta disciplina.
O Repositório no GitLab
editarO repositório para o projeto da disciplina pode ser encontrado no seguinte link:
https://gitlab.com/dandaara/ejtools
O repositório oficial pode ser encontrado no seguinte link: https://gitlab.com/ejudge/ejtools
Gerenciamento de Configuração de Software
editarOrganização, Responsabilidades e Interfaces
editarTodo o trabalho será desenvolvido pelos alunos da disciplina de GCS Dandara Aranha e João Henrique.
Ferramentas, Ambiente e Infra-estrutura
editarGerência de Configuração | |
---|---|
Ferramenta | Descrição |
Vagrant | Vagrant é uma ferramenta para construir ambientes completos de desenvolvimento. |
GitLab | Gerenciador de repositório de software. |
Linux Mint | é um sistema operacional baseado nas distribuições Ubuntu e Debian. |
VirtualBox | é um programa de máquina virtual. |
Gitlab CI | é o ambiente de Integração Contínua do GitLab. |
O Programa de Gerenciamento de Configuração
editarControle de Configuração e Mudança
editarO controle de mudanças será feito por meio da ferramenta Gitlab.
- Issues
Representação das tarefas a serem desenvolvidas ao longo do projeto. Serão adiconadas e retiradas de acordo com as necessidades.
- Branch
É uma ramificação do código. As branchs devem ser criadas de acordo com cada funcionalidade nova.
Marcos e Cronograma
editarMarcos do Projeto
editarMarcos | Atividade | Data Final |
---|---|---|
Marco 0 | Integração Contínua Utilizando a Ferramenta Gitlab CI | 10/10/2016 |
Marco 1 | Configurar ambiente de desenvolvimento com o Vagrant | 31/10/2016 |
Marco 2 | Empacotar o módulo Scoreboard para facilitação da instalação | 21/11/2016 |
Datas da disciplina
editarAtividade | Data |
---|---|
Entrega do Plano de Gerência de Configuração | 26/09/2016 |
Apresentação de andamento do projeto | 31/10/2016 |
Apresentação final do projeto | 05/12/2016 |
Andamento do Projeto | Status |
---|---|
Definição dos paramentos para Gerencia de Mudancas e Configuração da integração contínua | Concluído |
Configurar o Ambiente de Desenvolvimento utilizando a Ferramenta Vagrant | Concluído |
Empacotar o Projeto para o Utilização do mesmo pelos usuários | Concluído |
Cronograma
editarPeríodo | Objetivo |
---|---|
19/09 a 26/09 | Definição do Projeto e Escrita do Plano de GCS |
26/09 a 03/10 | Estudo da ferramenta de integração contínua GitLab CI |
03/10 a 10/10 | Implementação de integração contínua para o módulo scoreboard |
10/10 a 17/10 | Estudo da ferramenta Vagrant |
17/10 a 24/10 | Configurar o Ambiente de Desenvolvimento utilizando a Ferramenta Vagrant |
24/10 a 31/10 | Estudo/pesquisa ferramentas para empacotamento do módulo scoreboard |
31/10 a 07/11 | Início do empacotamento |
07/11 a 14/11 | Continuação de empacotamento do módulo scoreboard |
14/11 a 21/11 | Finalização do empacotamento e entrega final do projeto |
Resultados
editarIntegração Contínua usando o GitLab CI
editarO Gitlab oferece um serviço de integração contínua, o GitLab CI. A integração contínua do projeto foi feita utilizando esse serviço devido a sua simplicidade e praticidade.
Para utilizar o Gitlab CI basta adicionar um arquivo .gitlab-ci.yml para o diretório raiz do seu repositório, e configurar seu projeto gitlab usar um Runner, então em cada merge ou push no repositório ele vai contruir um build para verificar se a integração do projeto está ok .
Os passos seguidos para a configuração da integração contínua do projeto foram os seguintes:
1. Escreva testes para o módulo scoreboard
2. Crie um arquivo .gitlab-ci.yml na raíz do projeto
3. Configure o arquivo para realizar o build e executar os testes utilizando esse .gitlab-ci.yml como base.
4. Fazer um commit das alterações e subir para o gitlab.com
5. Habilitar os "Shared Runners".
O arquivo .gitlab-ci.yml do projeto foi feito para o módulo scoreboard e se encontra da seguinte maneira:
image: ubuntu:latest
before_script:
- apt-get update -y
- apt-get install --assume-yes g++ cmake qt5-default qtdeclarative5-dev libjsoncpp-dev
stages:
- build
- test
build:
stage: build
script:
- cd scoreboard
- cmake .
- make
tests:
stage: test
script:
- cd scoreboard
- cmake .
- make
- ctest --verbose
O arquivo .gitlab-ci.yml diz ao GitLab Runner o que fazer. Por padrão ele é executado com um processo de rês estágios: build, test, and deploy. Não é necessário utilizar todos os estágios, e no projeto foram utilizados apenas 2: build e test.
Como o módulo do scoreboard utiliza o CMake para contruir e compilar o projeto, o arquivo YML acima possui apenas os comandos para execução do mesmo
Se tudo estiver OK, vai aparecer uma marca de seleção verde associado com a pipeline do push ou merge request específico.
Implementação dos Testes para o módulo Scoreboard
editarO projeto utiliza o Google Test para testes automatizados do módulo Scoreboard.
O Google Teste é uma biblioteca de teste de unidade para a linguagem de programação C ++ , baseado na arquitetura xUnit. Os testes podem ser executados um de cada vez, ou mesmo ser chamado para executar todos de uma vez. Isso faz com que o tenhamos um processo de depuração muito específico que atende à necessidade do projeto.
Para executar o conjunto de testes, com cmake instalado, basta usar o comando ctest .
A flag --verbose também pode ser utilizada para uma saída detalhada.
Para mais informações sobre como os testes foram desenvolvidos ver : http://wiki.ros.org/gtest
Configuração do Ambiente de Desenvolvimento usando o Vagrant
editarO principal objetivo desta etapa é permitir que todo desenvolvedor possa contribuir com o projeto usando a mesma configuração.
O Ejudge já utilizava o software Vagrant para garantir um ambiente comum de desenvolvimento, composto por uma máquina virtual e as dependências de software. A distribuição Linux utilizada na máquina virtual é o Ubuntu 14.04 x64. Entretanto a máquina virtual e as dependências de software não eram configurados para o módulo Scoreboard. Sendo assim o principal trabalho aqui foi incluir as depêndencias e bibliotecas para tornar possível o desenvolvimento e evolução do módulo Scoreboard pelos contribuidores. O Vagrantfile pode ser visto na pasta principal dos repositórios.
Para inicar o ambient usando o vagrant, os seguintes comandos devem ser executados:
$ vagrant up
Logo após a configuração e execução das provisions, deve-se executar o comando:
$ vagrant ssh
Para acessar toda a estrutura de diretórios do ejudge, e necessário antes entrar na pasta /vagrant. Para sair do ambiente, basta executar o comando:
$ exit
Empacotamento do módulo Scoreboard
editarPara realização do empacotamento do módulo Scoreboard os seguintes passos foram seguidos:
1. Primeiramente foi necessário a instalação das seguintes dependências:
$ apt-get install --assume-yes g++ cmake qt5-default qtdeclarative5-dev libjsoncpp-dev
2. A criação de uma pasta exclusiva para o empacotamento:
$ mkdir empacotamentoScoeboard/
$ cd empacotamentoScoreboard/
3. Realizar o clone do projeto:
$ git clone git@gitlab.com:ejudge/ejtools.git
4. Entrar dentro da pasta do Scoreboard e criar uma pasta com o nome DEBIAN:
$ cd Ejtools/scoreboard
$ mkdir DEBIAN
$ cd DEBIAN
$ git clone git@gitlab.com:ejudge/ejtools.git
5. Dentro da pasta DEBIAN, criar um arquivo control e editar da seguinte maneira:
Package: scoreboard
Version: 1.0.0
Source: scoreboard
Section: unknown
Priority: optional
Maintainer: Dandara aranha <dandaraaranha@gmail.com>
Build-Depends: debhelper (>=9), g++, cmake, qt5-default, qtdeclarative5-dev, libjsoncpp-dev
Standards-Version: 3.9.8
Homepage: <https://gitlab.com/ejudge/ejtools>
Architecture: all
Description: Módulo do Ejtools para simulação de competições de Programação .
O ejtools é um conjunto de ferramentas para a automação de provas e competições de programação.
O projeto é composto de 7 módulos, onde apenas um (core) não é uma ferramenta:
*checker: script para a correção automática das soluções propostas;
*client: programa para o envio de soluções ao servidor;
*core: biblioteca estática com funcionalidades comuns;
*problems: scripts para a formatação e instalação de problemas;
*scoreboard: programa que representa o placar da competição;
*server: servidor que recebe as soluções propostas via rede;
*users: scripts para o cadastro de usuários.
6. Compilar o projeto e executar para verificar se tudo está ok: - Para compilar, volte para a pasta scoreboard e execute os seguintes comandos:
$ cd ..
$ cmake .
$ make
- Para executar , os seguintes comandos:
$ cd build
$ ./scoreboard
7. Com tudo funcionado corretamente, e com nossa estrutura criada pode-se criar o pacote .deb com o seguintes comandos:
$ sudo dpkg-deb --build scoreboard-1.0
8. Para instalação do pacote execute:
$ sudo dpkg -i scoreboard-1.0.deb
9. Para executar o scoreboard depois de instalado e verificar se a instalação foi realizada corretamente digite:
$ /build/scoreboard
Referências
editarhttps://docs.gitlab.com/ce/ci/quick_start/README.html
https://about.gitlab.com/2016/03/01/gitlab-runner-with-docker/
https://techbase.kde.org/Development/Tutorials/CMake_(pt_BR)#Executar_o_CMake
http://www.ibm.com/developerworks/aix/library/au-googletestingframework.html