vagrant-gpii-ci 0.0.1

data/lib/vagrant-gpii-ci/command/test.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+
+module VagrantPlugins
+  module Cienv
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "Manages QI environments"
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:init) do
+            require_relative "init"
+            InitEnvironment
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the sub-commands.
+            puts "Help not completed yet"
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant test [<args>]"
+            o.separator ""
+            o.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual command run `vagrant test -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-gpii-ci/config/config_folders.rb

@@ -0,0 +1,17 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+ 
+def config_folders(instance, vm_id, apps, vagrant_ci_path)
+
+  instance.vm.synced_folder ".", "/vagrant" # Always needed by the provisioning
+  instance.vm.synced_folder vagrant_ci_path + "/provisioning", "/provisioning" # Always needed by the provisioning
+
+  # Share folder if the "src" variable is set
+  apps.each do |config|
+    if config["run_in"] == vm_id and config["folder"] and config["folder"]["src"] then 
+      instance.vm.synced_folder config["folder"]["src"], config["folder"]["dest"]
+    end
+  end if apps
+
+end
+

data/lib/vagrant-gpii-ci/config/config_network.rb

@@ -0,0 +1,69 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Builds a file with the list of pairs IP address: hostname which will be read
+# by Ansible to setup the hosts file in each VM
+# Params:
+# +env_vms+: object with the definition of the virtual machines
+
+def build_hosts_list(env_vms)
+
+  int_id = 10
+
+  first = true
+  env_vms.each do |vm, vmconfig|
+    vmconfig["networks"].each do |name, netcfg|
+      if netcfg["type"] == "private" then
+        if netcfg['ip'].nil? then
+          netcfg['ip'] = "192.168.50." + int_id.to_s
+          #add the default IP to the environment definnition
+          env_vms[vm]["networks"][name]["ip"] = "192.168.50." + int_id.to_s
+          int_id += 1
+        end
+        if first then
+          $base_vars = "vms_hosts={"
+          $base_vars << "\"#{netcfg['ip']}\":\"#{vm}\""
+          first = false
+        elsif
+          $base_vars << ",\"#{netcfg['ip']}\":\"#{vm}\""
+        end
+      end
+    end if vmconfig["networks"]
+  end
+  $base_vars << "}" if $base_vars
+end
+
+# Configure the network section of a virtual machine. You can set the type of
+# the network, the ip address if needed and a list of forwarded ports.
+# Params:
+# +instance+: The instance of the VM to configure
+# +vm_config+: the definition of the VM. There are to type of networks: private
+# - where the IP setting is available, and public - where virtualbox will set
+# the interface as an external NIC.
+
+def config_network(instance, vm_config)
+
+  vm_config["networks"].each do |network, config|
+    if config["type"] == "private" then
+      if config["ip"] then
+        instance.vm.network :private_network, ip: config["ip"]
+      end
+    elsif config["type"] == "public" then
+      instance.vm.network :public_network
+    end
+  end if vm_config["networks"]
+
+  vm_config["ports"].each do |port, config|
+
+    raise "At least the guest port is needed in 'guest_port' variable" \
+      if config["guest_port"].nil?
+
+    instance.vm.network "forwarded_port",
+      guest: config["guest_port"],
+      host: config["host_port"] || config["guest_port"],
+      protocol: config["protocol"] || "tcp",
+      auto_correct: config["auto_correct"] || true
+  end if vm_config["ports"]
+
+end
+

data/lib/vagrant-gpii-ci/config/config_provider.rb

@@ -0,0 +1,40 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+def config_provider(instance, vm_config, global_config)
+
+  if global_config["provider"] == "virtualbox" then 
+
+    instance.vm.provider :virtualbox do |vm|
+
+      vm.linked_clone = vm_config["clone"] || global_config["clone"] || false
+      
+      vm.customize ["modifyvm", :id, "--memory", vm_config["memory"] || global_config["memory"] ]
+      vm.customize ["modifyvm", :id, "--cpus", vm_config["cpu"] || global_config["cpu"] ]
+
+      if vm_config["gui"] == true then
+        vm.customize ["modifyvm", :id, "--vram", "128"]
+        vm.customize ["modifyvm", :id, "--accelerate3d", "on"]
+      end
+      
+      if vm_config["sound"] == true then
+        vm.customize ["modifyvm", :id, "--audio", "null", "--audiocontroller", "ac97"]
+      end
+
+      vm.customize ["modifyvm", :id, "--ioapic", "on"]
+      vm.customize ["setextradata", "global", "GUI/SuppressMessages", "all"]
+
+      vm.gui = vm_config["gui"] || global_config["gui"] || false
+    end
+
+    instance.vm.box = vm_config["box"]
+
+  elsif global_config["provider"] == "libvirt" then
+      raise "Not supported yet"
+  else
+      raise "Provider not defined in global configuration" unless global_config.include?('provider')
+      raise "Provider #{global_config['provider']} not supported"
+  end
+
+end
+

data/lib/vagrant-gpii-ci/config/config_provision.rb

@@ -0,0 +1,50 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require 'yaml'
+
+def config_provision(instance, vm_config, vm_id, apps, vagrant_ci_path)
+
+
+  apps.each do |config|
+    if config["run_in"] == vm_id then
+      if ARGV[0] == "up" then
+        app = config["app_name"] #app_name
+        stack = config["software_stack"]
+
+        #check if every file is in place
+        raise "File vagrant/provisioning/#{stack}-requirements.yml doesn't exist"\
+          unless File.file?(vagrant_ci_path + "/provisioning/#{stack}-requirements.yml")
+        raise "File vagrant/provisioning/#{stack}-vars.yml doesn't exist"\
+          unless File.file?(vagrant_ci_path + "/provisioning/#{stack}-vagrant-vars.yml")
+        raise "File vagrant/provisioning/#{stack}-playbook.yml doesn't exist"\
+          unless File.file?(vagrant_ci_path + "/provisioning/#{stack}-playbook.yml")
+        raise "File vagrant/provisioning/base-playbook.yml doesn't exist"\
+          unless File.file?(vagrant_ci_path + "/provisioning/base-playbook.yml")
+
+        qi_vars = JSON.dump(YAML::load(config.to_yaml))
+
+        basecmd = "sudo PYTHONUNBUFFERED=1 VM_HOSTNAME=#{vm_id} "\
+                  "ansible-playbook --extra-vars='#$base_vars' /provisioning/base-playbook.yml"
+        instance.vm.provision "shell", inline: basecmd
+
+        cmds = \
+        "sudo ansible-galaxy install -fr /provisioning/#{stack}-requirements.yml \n"\
+        "sudo VARS_FILE=#{stack}-vagrant-vars.yml PYTHONUNBUFFERED=1 \\\n"
+        if config["deploy"] then
+          cmds << "ansible-playbook --tags='install,configure,deploy' --extra-vars='#{qi_vars}' /provisioning/#{stack}-playbook.yml"
+        else
+          cmds << "ansible-playbook --tags='install,configure' --extra-vars='#{qi_vars}' /provisioning/#{stack}-playbook.yml"
+        end
+        instance.vm.provision "shell", inline: cmds
+
+      elsif ARGV[0] == "provision" and config["test_cmds"] and config["folder"] and config["folder"]["dest"] then
+        test_cmds = "cd #{config['folder']['dest']} \n"
+        config["test_cmds"].each do |cmd|
+          test_cmds << "DISPLAY=:0 " + cmd + "\n"
+        end unless config["test_cmds"].nil?
+        instance.vm.provision "shell", privileged: false, inline: test_cmds
+      end
+    end
+  end if apps
+end

data/lib/vagrant-gpii-ci/plugin.rb

@@ -0,0 +1,59 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant QI plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.8.0"
+  raise "The Vagrant QI plugin is only compatible with Vagrant 1.8+"
+end
+
+module VagrantPlugins
+  module Cienv
+    class Plugin < Vagrant.plugin("2")
+      name "Cienv"
+      description "This plugin enabled Vagrant to work with QI QI environments"
+
+      action_hook(:build_config, :environment_load) do |hook|
+        hook.prepend(VagrantPlugins::Cienv::Action::BuildVagrantfile)
+      end
+      command("test") do
+         require File.expand_path("../command/test", __FILE__)
+         Command::Test
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_cienv")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end
+
+require 'vagrant-gpii-ci/plugin'

data/lib/vagrant-gpii-ci/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Cienv
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-gpii-ci.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-gpii-ci/plugin"
+
+module VagrantPlugins
+  module Cienv
+    lib_path = Pathname.new(File.expand_path("../vagrant-gpii-ci", __FILE__))
+    autoload :Action, lib_path.join("action")
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/qi.yml.template

@@ -0,0 +1,56 @@
+---
+
+# This is a template .qi.yml file. It shows the available variables to setup the
+# applications that will run in the VM enviroment. More examples are available
+# in the 'samples' directory.
+
+email: anonymous@testdomain.org
+# env_runtime variable set the VM enviroment that will be used to run the
+# applications below. You can see the available environments in 'env' directory
+env_runtime: linux-desktop
+
+# The apps variable lists the applications that must be installed. The
+# properties of each application define the source of the code, the way that are
+# deployed and how should run
+
+apps:
+# The app_name variable set an unique identifier that can be used to create the
+# instances of the running applications, or to name a directory where all the
+# files related to the application will be stored.
+  - app_name: name-of-application
+# the git_repository variable is used to retrieve the source code of the
+# application if the code is not available through a shared folder. You can also
+# set a git_branch variable to set the branch,tag,commit or pull request to
+# retrieve.
+    git_repository: https://github.com/user/repo.git
+    git_branch: pr/1
+# The software_stack variable set the software applicance that will be installed
+# in the vm. The avaliable software stacks are in the provisioning directory.
+    software_stack: [nodejs | couchdb]
+# The deploy variable notifies to the stack that this application will be
+# launched as a service. Note that the stack must know how to launch this
+# application.
+    deploy: false
+# The 'run_in' variable indicates which VM of the environment will contain the
+# application. To know the name of the VMs see the environment files found in
+# the 'env' directory.
+    run_in: fedora
+# The setup variable list the command that will be executed after the
+# provisioning of the software_stack is finished.
+    setup:
+      - command 1
+      - command 2
+# The test_cmds variable list the commands that will be executed on every
+# 'vagrant provision' command. This list usually have the commands that test the
+# application, so every time you run 'vagrant provision' all these commands
+# will run the tests of your application.
+    test_cmds:
+      - test command 1
+      - test command 2
+# The folder variable sets the installation folder of the application. The
+# 'dest' child variable is the destination folder where the application will be
+# installed. If you add a 'src' child variable Vagrant will map that path from
+# the host to the 'dest' path in the VM. Vagrant will create a shared folder
+# using this information.
+    folder:
+      dest: "/app/{{ app_name }}"

data/samples/README.md

@@ -0,0 +1,12 @@
+Examples
+-------
+
+This folder contains several examples of how to use the vagrant-gpii-ci plugin. To
+run any of these examples:
+
+ 1. Copy the directory in some place
+ 2. Go to that directory
+ 2. Install the plugin
+    `vagrant plugin install vagrant-gpii-ci`
+ 3. Run vagrant:
+    `vagrant up && vagrant test`

data/samples/gpii-linux/.qi.yml

@@ -0,0 +1,22 @@
+---
+
+email: anonymous@testdomain.org
+env_runtime: linux-desktop
+
+apps:
+  - app_name: gpii-linux
+    git_repository: https://github.com/GPII/linux.git
+    software_stack: gpii-linux
+    folder:
+      dest: /app/gpii-linux
+    run_in: fedora
+    deploy: false
+    setup:
+      - npm install
+      - sudo npm install -g grunt-cli node-gyp
+      - grunt --force build
+    test_cmds:
+      - "find -name \\*.sh -exec chmod +x '{}' \\;"
+      - node tests/AcceptanceTests.js
+      - cd tests && bash UnitTests.sh
+

data/samples/gpii-linux-production/.qi.yml

@@ -0,0 +1,41 @@
+---
+
+# This sample will spin up two VMs, one server without desktop interface, and
+# another one with a desktop interface called 'fedora', both are provided by the
+# file 'production.json'. Then 3 applications will be installed, gpii-linux will
+# be installed in the 'fedora' VM and couchdb and preferences will be installed
+# in then 'server' VM. The commands listed in the 'setup' variable will run at
+# 'vagrant up' time, and the commands listed in the 'test_cmds' variable will be
+# run using the 'vagrant provision' command.
+
+email: anonymous@testdomain.org
+env_runtime: production
+
+apps:
+  - app_name: gpii-linux
+    git_repository: https://github.com/GPII/linux.git
+    software_stack: gpii-linux
+    folder:
+      dest: /app/gpii-linux
+    run_in: fedora
+    deploy: false
+    setup:
+      - npm install
+      - sudo npm install -g grunt-cli node-gyp
+      - grunt --force build
+    test_cmds:
+      - "find -name \\*.sh -exec chmod +x '{}' \\;"
+      - node tests/AcceptanceTests.js
+      - cd tests && bash UnitTests.sh
+
+  - app_name: couchdb
+    software_stack: couchdb
+    run_in: server
+    deploy: true 
+
+  - app_name: preferences
+    software_stack: preferences
+    run_in: server
+    deploy: true
+    folder:
+      dest: "/app/{{ app_name }}" 

data/samples/gpii-nexus/.qi.yml

@@ -0,0 +1,24 @@
+---
+
+# This sample fetchs the Pull Request #1 of the GPII/nexus repository, spin up a
+# fedora VM an run the tests when 'vagrant provision' command is run.
+
+email: anonymous@testdomain.org
+env_runtime: linux-desktop
+
+apps:
+  - app_name: gpii-nexus
+    git_repository: https://github.com/GPII/nexus.git
+    git_branch: pr/1
+    software_stack: nodejs
+    folder:
+      dest: /app/gpii-nexus
+    run_in: fedora
+    deploy: false
+    setup:
+      - npm install
+      - sudo npm install -g grunt-cli node-gyp
+      - grunt --force build
+    test_cmds:
+      - node tests/all-tests.js
+

data/samples/gpii-universal/.qi.yml

@@ -0,0 +1,27 @@
+---
+
+# This sample will spin up one VM with the desktop interface (linux-desktop
+# environment). Then will deploy an application named 'gpii-universal' which is
+# a clone of the repository https://github.com/GPII/universal.git. It will exec
+# the commands listed in the 'setup' variable at 'vagrant up' time, and the
+# 'test_cmds' commands will be executed with 'vagrant provision'.
+
+email: anonymous@testdomain.org
+env_runtime: linux-desktop
+
+apps:
+  - app_name: gpii-universal
+    git_repository: https://github.com/GPII/universal.git
+    software_stack: nodejs
+    folder:
+      dest: /app/gpii-universal
+    run_in: fedora
+    setup:
+      - npm install
+      - "sudo npm install -g testem"
+      - "git clone {{ git_repository }} /app/gpii-universal/node_modules/universal"
+    test_cmds:
+      - "npm test"
+      - "testem ci --file tests/web/testem_qi.json"
+      - "node tests/ProductionConfigTests.js"
+

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'vagrant/cienv'

data/spec/vagrant/cienv_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Vagrant::Cienv do
+  it 'has a version number' do
+    expect(Vagrant::Cienv::VERSION).not_to be nil
+  end
+
+  it 'does something useful' do
+    expect(false).to eq(true)
+  end
+end

data/vagrant-cienv.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-gpii-ci/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-gpii-ci"
+  spec.version       = VagrantPlugins::Cienv::VERSION
+  spec.authors       = ["Alfredo Matas"]
+  spec.email         = ["amatas@gmail.com"]
+
+  spec.summary       = %q{Vagrant CI environment builder}
+  spec.description   = %q{Vagrant CI environment builder}
+  spec.homepage      = "http://github.com/amatas/vagrant-gpii-ci.git"
+  spec.license       = "MIT"
+
+  # 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.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files`.split($\)
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "method_source", "~> 0.8.2"
+end