Ejudge.

Alunos:

Dandara Pereira Aranha - 110010256

João Henrique Pereira - 150132042

Introdução

Visão Geral

O 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

O 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

AS 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

O 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

Organização, Responsabilidades e Interfaces

Todo o trabalho será desenvolvido pelos alunos da disciplina de GCS Dandara Aranha e João Henrique.

Ferramentas, Ambiente e Infra-estrutura

Gerê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

Controle de Configuração e Mudança

O 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

Marcos do Projeto

Marcos	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

Atividade	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

Perí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

Integração Contínua usando o GitLab CI

O 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

O 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

O 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

Para 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

https://docs.gitlab.com/ce/ci/quick_start/README.html

https://about.gitlab.com/2016/03/01/gitlab-runner-with-docker/

http://wiki.ros.org/gtest

https://techbase.kde.org/Development/Tutorials/CMake_(pt_BR)#Executar_o_CMake

http://www.ibm.com/developerworks/aix/library/au-googletestingframework.html

https://github.com/google/googletest