Falcon Framework

Fonte: Wikiversidade
Saltar para a navegação Saltar para a pesquisa
Logo Falcon Framework

Responsáveis[editar | editar código-fonte]

Thiago Meira Bernardes

Luis Filipe Resende Vilela

Introdução[editar | editar código-fonte]

Este plano de Gerência de Configuração de Software visa descrever as atividades do Gerenciamento de Controle e Mudança que serão executados durante os ciclo de vida do projeto Falcon Framework.

A proposta do Falcon é o desenvolvimento de um Framework que possibilite automatizar o processo de desenvolvimento da conexão cliente-servidor, diminuindo o esforço e aumentando a produtividade dessa atividade do processo de desenvolvimento de software. O Falcon irá gerar código do servidor a partir de uma modelagem gráfica, e seguindo o padrão de resposta desse servidor gerado, gerará também o SDK para a camada cliente se conectar com o servidor. Além de oferecer a conexão facilitada do Cliente-Servidor, o Falcon fornecerá automaticamente a funcionalidade de sincronização e persistência dos dados desejados. Na próxima sessão os recursos estão ordenados por ordem de prioridade, assim os desenvolvedores terão menos esforço para construção desse módulo nos softwares desenvolvidos.

Obs: Este Plano de Gerência de Configuração de Software foi desenvolvido na disciplina de Gerência de Configuração de Software do 1 Semestre de 2016 na FGA/UnB-Gama

Finalidade[editar | editar código-fonte]

A finalidade deste documento é documentar um padrão a ser seguido durante o andamento do projeto, visando o controle e organização do mesmo.

Escopo[editar | editar código-fonte]

Este Plano de Gerenciamento de Configuração é destinado para todos os integrantes da equipe responsável pelo desenvolvimento do Falcon Framework nas diciplinas de Medição e Análise, Desenho de Software e Modelagem de Processos.

Na disciplina de Gerência de configuração o objetivo principal é criar uma automação do empacotamento do Falcon Framework módulo de Geração de Servidor, a cada build lançada no repositório remoto, a integração contínua irá gerar um novo empacotamento e disponibilizará para download. O Módulo do produto já está pronto na linguagem Ruby e gerando servidores em Ruby on Rails, também será expandido para gerar servidores em NodeJS.

Papéis e Responsabilidades[editar | editar código-fonte]

Papel Responsabilidade Responsável
Gestor de configuração do projeto Acompanha as alterações dos artefatos, itens de configuração relacionados ao projeto Luís
Gestor de ferramentas de gerência de configuração Realiza a manutenção da infraestrutura, isto é, a plataforma operacional e ferramentas utilizadas no processo de GCS. Luís e Thiago
Gestor de configuração de software Gerencia e aprova as atividades de GCS Thiago
Auditor de configuração de software Realiza a auditoria de configuração no projeto Luís e Thiago
Desenvolvedor Produz os itens de configuração que são gerenciados, no caso, o código-fonte do Geração de Servidor do Falcon Framework Luís, Thiago e Gabriel Araújo

Cronograma[editar | editar código-fonte]

Iteração Período Macro Atividade Status
1 25/04 -> 01/05 Redigir Plano de Gerência de Configuração Done
2 01/05 -> 08/05 Analisar as ferramentas a serem utilizadas Done
3 08/05 -> 15/05 Implementar empacotamento para Linux Done
4 15/05 -> 22/05 Implementar empacotamento para OSX Done
5 22/05 -> 29/05 Implementar empacotamento para Windows Done
6 29/05 -> 05/06 Implementar Integração Contínua com empacotamento automático Done
7 05/06 -> 12/06 Analisar ambiente que será usado para testes Done
8 12/06 -> 19/06 Implementar Integração Contínua para testes Done

Organização[editar | editar código-fonte]

Política de Branchs[editar | editar código-fonte]

Para a política de branchs, será utilizado o model de branchs criado por Vincent Driessen's. Que é uma estratégia de gerenciamento de releases e branch que ajudará a equipe de desenvolvimento no rastreamento das features implementadas, ajustes feitos e grades releases do projeto.

Git-flow[editar | editar código-fonte]

  • Production branch: master
  • Development branch: develop

Branch prefixes:

  • Feature branch prefix: feature/
  • Release branch prefix: release/
  • Hotfix branch prefix: hotfix/
  • Version tag prefix: ""
  • Support branch prefix: support/

Ferramentas[editar | editar código-fonte]

Ferramenta Versão Descrição Disponibilização
Atom 1.7.4 Editor de Texto. https://atom.io
GitLab CI Serviços para integração contínua. https://about.gitlab.com/gitlab-ci/
Rubygem 2.5.1 Gerenciador de pacotes ruby (gems) https://rubygems.org
Bundler 1.11.2 Gerenciador de dependências ruby http://bundler.io

Controle de Configuração[editar | editar código-fonte]

Empacotamento[editar | editar código-fonte]

O empacotamento foi realizado através do bundler, que empacota as dependências necessárias para instalar o Falcon. No arquivo .gemspec abaixo, realizamos a configuração de atributos padrão, como: plataforma, nome, versão, descrição, autores, tipo de licença. E realizamos também a adição das dependências da gem, como: bundler, activesupport e o próprio ruby versão 2.3.0.

O seguinte pacote foi configurado com ajuda do seguinte tutorial http://railscasts.com/episodes/245-new-gem-with-bundler

# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'falcon_factory/version'

Gem::Specification.new do |spec|

  spec.platform    = Gem::Platform::RUBY
  spec.name        = 'falcon_factory'
  spec.version     = FalconFactory::VERSION
  spec.summary     = 'Backend web application framework.'
  spec.description = 'Will generate backend for you through a DB model.'

  spec.authors       = ["thiagotmb"]
  spec.email         = ["tmb0710@gmail.com"]
  spec.license       = "MIT"
  spec.required_ruby_version     = '>= 2.3.0'

  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
  spec.executables   = ["falcon_factory"]
  spec.require_paths = ["lib"]

  spec.add_dependency "activesupport-inflector"
  spec.add_dependency "activesupport", "~> 5.0.0.rc1"
  spec.add_dependency "bundler", "~> 1.11"

  spec.add_development_dependency 'rspec'
  spec.add_development_dependency "rake", "~> 10.0"

  spec.post_install_message = "Thanks for install falcon_factory!"

  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
  # delete this section to allow pushing this gem to any host.
  if spec.respond_to?(:metadata)
    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
  else
    raise "RubyGems 2.3.0 or newer is required to protect against public gem pushes."
  end

end

Antes do empacotamento a instalação do falcon seguia os seguintes passos:

  1. Clone o Projeto:
    git clone git@gitlab.com:FalconTeam/server_generetor.git
    
  2. Defina o seu arquivo falcon_schema.yml
  3. Execute:
    ruby falcon_main.rb
    
    Isso vai gerar um script falcon.sh que será responsável por criar o seu servidor.
  4. Execute:
    bash falcon.sh
    
    Isso vai gerar uma aplicação baseada no seu schema. Se você não tem as ferramentas necessárias para gerar o servidor, o script irá instalá-las e isso pode levar alguns minutos.
  5. execute: 'cd ..'
  6. execute: 'cd falcon_generated_app'
  7. execute: 'cd your_app_name'
  8. execute: 'rails s'
  9. Aproveite sua API

Nesse modo anterior, era necessário clonar todo o projeto e executar alguns comandos específicos para conseguir gerar o servidor. Porém, a partir do empacotamento do falcon em uma gem, a instalação passou a ser realizada da seguinte maneira:

  1. Realiza o download da falcon gem: falcon_factory
  2. Instale a gem:
    gem install falcon_factory-0.0.1.gem
    
  3. Defina o seu schema falcon_schema.yml
  4. Execute o script abaixo para gerar seu servidor:
    falcon_factory generate -m your_falcon_schema_file.yml -t existent_folder_to_save_de_server
    
  5. Entre na pasta em que o servidor foi gerado:
    cd my_generated_app_path/falcon_generated_app/my_app_name
    
  6. Execute: 'rails s'
  7. Aproveite sua API

Integração contínua[editar | editar código-fonte]

A integração contínua foi realizada utilizando uma ferramenta do próprio GitLab, o GitLab CI. O GitLab CI é uma ferramenta Open Source e é totalmente integrada ao GitLab, além de ser escalável, pois executa os testes distribuídos em máquinas separadas, que você pode adicionar tantas quanto deseja, ele é fácil de aprender e possui uma documentação enxuta e objetiva. O GitLab CI também é multi-plataforma e multi-linguagem , ou seja, executa builds em Unix, OSX e Windows, além da possibilidade do código ser em qualquer linguagem.

A integração foi realizada a partir de uma vm com imagem do ruby 2.3.0, que é a versão necessária para executar a gem. Foram criados dois "jobs": um para teste e o outro para deploy. O primeiro "job" para teste executa os testes e se estes passarem, iniciará o "job" de deploy. Nesse "job" de deploy é realizado o empacotamento em uma .gem e publicada no dropbox. Abaixo está o .gitlab-ci.yml:

image: ruby:2.3

before_script:
  - apt-get update -qq && apt-get install -y -qq sqlite3 libsqlite3-dev nodejs
  - ruby -v
  - which ruby
  - gem install bundler --no-ri --no-rdoc
  - bundle install --gemfile falcon_factory_gem/Gemfile --jobs $(nproc)  "${FLAGS[@]}"

Unit Tests:
  stage: test
  script:
    - rspec

Release to dropbox:
 stage: deploy
 script:
  - cd falcon_factory_gem
  - rake build
  - >- 
      curl
      -X POST https://content.dropboxapi.com/2/files/upload 
      --header "Authorization: Bearer 7MrPrA4nZMEAAAAAAAAT6G6uJ97ljn8HUw5KgJLykFg_dKnRycGmkNRYMYYJj0bM"
      --header "Dropbox-API-Arg: {\"path\": \"/Releases/falcon_factory_gem/falcon_factory-0.0.1.gem\",\"mode\": \"add\",\"autorename\": true,\"mute\": false}"
      --header "Content-Type: application/octet-stream"
      --data-binary pkg/falcon_factory-0.0.1.gem

Ambiente[editar | editar código-fonte]

O gerenciamento do ambiente de desenvolvimento está sendo automatizado utilizando o `Vagrant 1.8.4` e o Cheff. A equipe ainda nao conclui o completamente a configuração do ambiente que precisa contar com uma instância `Ubuntu` e `ruby <= 2.3.0`. Segue o arquivo Vagrant configurado:

# -*- mode: ruby -*-
# vi: set ft=ruby :

VAGRANTFILE_API_VERSION = "2"

Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
  # Use Ubuntu 14.04 Trusty Tahr 64-bit as our operating system
  config.vm.box = "ubuntu/trusty64"

  # Configurate the virtual machine to use 2GB of RAM
  config.vm.provider :virtualbox do |vb|
    vb.customize ["modifyvm", :id, "--memory", "2048"]
  end

  # Forward the Rails server default port to the host
  config.vm.network :forwarded_port, guest: 3000, host: 3000

  # Use Chef Solo to provision our virtual machine
  config.vm.provision :chef_solo do |chef|
    chef.cookbooks_path = ["cookbooks", "site-cookbooks"]
    chef.add_recipe "apt"
    chef.add_recipe "ruby_build"
    chef.add_recipe "rbenv::user"
    chef.add_recipe "rbenv::vagrant"
    chef.add_recipe "vim"
    chef.add_recipe "mysql::server"
    chef.add_recipe "mysql::client"

    # Install Ruby 2.2.1 and Bundler
    # Set an empty root password for MySQL to make things simple
    chef.json = {
      rbenv: {
        user_installs: [{
          user: 'vagrant',
          rubies: ["2.3.1"],
          global: "2.3.1",
          gems: {
            "2.3.1" => [
              { name: "bundler" }
            ]
          }
        }]
      },
      mysql: {
        server_root_password: ''
      }
    }
  end
end

Arquivo Cheff configurado:

site "http://community.opscode.com/api/v1"

cookbook 'apt'
cookbook 'build-essential'
cookbook 'mysql', '5.5.3'
cookbook 'ruby_build', '2.3.0'
cookbook 'vim'