vagrant-qienv 0.0.1

data/lib/provisioning/preferences-playbook.yml

@@ -0,0 +1,13 @@
+---
+
+- hosts: localhost
+  become: true
+
+  vars_files:
+    - "{{ lookup('env', 'VARS_FILE') }}"
+
+  roles:
+    - facts
+    - nodejs
+    - preferences
+

data/lib/provisioning/preferences-requirements.yml

@@ -0,0 +1,9 @@
+- src: http://github.com/idi-ops/ansible-facts.git
+  name: facts
+
+- src: https://github.com/idi-ops/ansible-nodejs.git
+  name: nodejs
+
+- src: https://github.com/gpii-ops/ansible-preferences-server.git
+  name: preferences
+

data/lib/provisioning/preferences-vagrant-vars.yml

@@ -0,0 +1,5 @@
+---
+
+nodejs_app_install_dir: "{{ folder['dest'] }}" 
+nodejs_app_git_repo: https://github.com/GPII/universal.git
+nodejs_app_git_branch: "{{ git_branch | default('master')  }}"

data/lib/vagrant-qienv.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-qienv/plugin"
+
+module VagrantPlugins
+  module Cienv
+    lib_path = Pathname.new(File.expand_path("../vagrant-qienv", __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/lib/vagrant-qienv/action.rb

@@ -0,0 +1,122 @@
+require "pathname"
+require 'json'
+require 'yaml'
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Cienv
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_init
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use InitEnvironment
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :InitEnvironment, action_root.join("init_environment")
+
+      class BuildVagrantfile
+
+        def gem_path
+          Pathname.new(File.dirname __dir__)
+        end
+
+        def project_home
+          environment = @env[:env]
+          environment.instance_variable_get(:@cwd)  
+        end
+
+        def vagrant_home
+          project_home.join(Vagrant::Environment::DEFAULT_LOCAL_DATA)
+        end
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          environment = @env[:env]
+
+          # Only make all the magic if the .qi.yml definition file is found
+          return if !File.exist?(project_home.join(".qi.yml"))
+
+          require_relative "config/config_provider.rb"
+          require_relative "config/config_provision.rb"
+          require_relative "config/config_network.rb"
+          require_relative "config/config_folders.rb"
+
+          # $vagrant_vmenv_path = vagrant_home.to_s + "/provision-ci/"
+
+          # load the .qi.yml file
+          qi_file = File.expand_path (project_home.join(".qi.yml"))
+          qi_definition = YAML.load(File.read(qi_file))
+
+          # Copy enviroments and playbooks to home dir if needed
+          FileUtils.mkdir(vagrant_home) if !File.exist?(vagrant_home)
+          FileUtils.mkdir(vagrant_home.join('provision-ci')) if !File.exist?(vagrant_home.join('provision-ci'))
+          FileUtils.cp_r(gem_path.join('envs'), vagrant_home.join('provision-ci/envs')) if !File.exist?(vagrant_home.join('provision-ci/envs'))
+          FileUtils.cp_r(gem_path.join('provisioning'), vagrant_home.join('provision-ci/provisioning')) if !File.exist?(vagrant_home.join('provision-ci/provisioning'))
+
+          # load the environment based on "env_runtime" variable of .qi.yml
+          vagrant_env = qi_definition["env_runtime"] || "default"
+          environment_file = File.expand_path(vagrant_home.to_s + "/provision-ci/envs", File.dirname(__FILE__)) +
+                             File::SEPARATOR + vagrant_env
+          if File.exists?(environment_file + ".json")
+            environment_ci = JSON.parse(File.read(environment_file + ".json"))
+          elsif File.exists?(environment_file + ".yml")
+            environment_ci = YAML.load(File.read(environment_file + ".yml"))
+          else
+            raise "Environment_ci config file not found, see envs directory\n #{environment_file}"
+          end
+
+          # build the host list of the VMs used, very useful to allow the communication
+          # between them based on the hostname and IP stored in the hosts file
+          build_hosts_list(environment_ci["vms"])
+
+          vagrantfile_proc = Proc.new do
+            Vagrant.configure(2) do |config|
+
+              environment_ci["vms"].each do |vm_id, vm_config|
+
+                config.vm.define vm_id, autostart: vm_config["autostart"] do |instance|
+
+                  # Ansible handles this task better than Vagrant
+                  #instance.vm.hostname = vm_id
+
+                  config_provider(instance, vm_config, environment_ci["global"])
+
+                  config_provision(instance, vm_config, vm_id, qi_definition["apps"], vagrant_home.join('provision-ci').to_s)
+
+                  config_network(instance, vm_config)
+
+                  config_folders(instance, vm_id, qi_definition["apps"], vagrant_home.join('provision-ci').to_s)
+
+                end
+              end
+            end 
+          end
+
+          # The Environment instance has been instantiated without a Vagrantfile
+          # that means that we need to store some internal variables and 
+          # instantiate again the Vagrantfile instance with our previous code.
+
+          environment.instance_variable_set(:@root_path, project_home)
+          environment.instance_variable_set(:@local_data_path, vagrant_home) 
+
+          # the cienv code will be the first item to check in the list of
+          # Vagrantfile sources
+          config_loader = environment.config_loader
+          config_loader.set(:cienv, vagrantfile_proc.call)
+          environment.instance_variable_set(:@vagrantfile, Vagrant::Vagrantfile.new(config_loader, [:cienv, :home, :root]))
+          
+        end
+        def call(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qienv/action/init_environment.rb

@@ -0,0 +1,24 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cienv
+    module Action
+
+      # This action sets up the QI QI environment
+      class InitEnvironment
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_qi::action::init_environment")
+        end
+
+        def call(env)
+          puts "i am inside class InitEnvironment"
+          @logger.info('i am inside class InitEnvironment - call()')
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-qienv/command/base.rb

@@ -0,0 +1,19 @@
+require "vagrant/plugin/state_file"
+
+module VagrantPlugins
+  module Cienv
+    module Command
+      class Base < Vagrant.plugin("2", :command)
+        # This is a helper for executing an action sequence with the proper
+        # environment hash setup so that the plugin specific helpers are
+        # in.
+        #
+        # @param [Object] callable the Middleware callable
+        # @param [Hash] env Extra environment hash that is merged in.
+        def action(callable, env=nil)
+          @env.action_runner.run(callable, env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qienv/command/init.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module Cienv
+    module Command
+      class InitEnvironment < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant qi init [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
+
+          # List the installed plugins
+          action(Action.action_init)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qienv/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-qienv/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-qienv/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-qienv/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
+