vagrant-dotvm 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48da5ae40935aab0b20cb682da883e4a47789297
-  data.tar.gz: f35a30c07db80def6746151e3402fe8e7ee97167
+  metadata.gz: 5f0cf0b9fa0ed709ac916220979c7ef5d83252a2
+  data.tar.gz: 09c15695b3db78795e53e1adc2e06e57731b29a1
 SHA512:
-  metadata.gz: 60644d8db7e1ebd44ebd79108fc24f62743e421e42f616fd7da65d27e867771195fd6bc5216ecbcdf986b54c1a433085016d6cf3a00fb4939cd8be00e10baa64
-  data.tar.gz: 925b895413c55f0322c12d67548860a04a6fd688991e9abe9a1f80867f6fa873b95571dac234deb0fa132d0af15e81285bd07d3ff068e7f5ce6987ca0e600c61
+  metadata.gz: d08bff1d15b8f04d0d1cf0dfc2cc9907d719cbc3806846756782e0ba6d83fdcbfde504a8e394bec7b43c82e473049f2162a8d229c4c7eb21053f93f681036302
+  data.tar.gz: d56381df9d695c16d7f09d24e76770b875f12617ea9163459c99640ca0084fb349104d68adff69b2a84f7e7a7d5b3e536efe0b6ab8b38c12250c3a64ab92fa78

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.15.0
+* Ability to set run option on provision
+* Fix privileged option in provision
+* Ability to setup static routes
+
 # 0.14.0
 * Ability to configure autostart option
 

data/README.md

@@ -2,7 +2,7 @@
 
 ## What is that?
 DotVm is vagrant plugin for easier maintenance of multi machine configurations.
-It allows you to plugin multiple directories, where each one can hold multiple YAML files, where each one can define multiple machines.
+DotVm joins easy syntax of YAML files with flexibility offered by configuration exploded into several small files.
 
 ## How to start using DotVm
 First you need to install DotVm plugin:

data/examples/config/projects/playground/main.yaml

@@ -37,6 +37,7 @@ machines:
         destination: "~/config.ini"
       - type: shell
         path: "%project.host%/bootstrap.sh"
+        privileged: true
         args:
           - "%project.guest%"
       - type: puppet

data/lib/vagrant-dotvm.rb

@@ -4,5 +4,6 @@ require 'yaml'
 require 'vagrant-dotvm/plugin'
 require 'vagrant-dotvm/version'
 require 'vagrant-dotvm/dotvm'
+require 'vagrant-dotvm/defaults'
 require 'vagrant-dotvm/configparser'
 require 'vagrant-dotvm/configinjecter'

data/lib/vagrant-dotvm/configinjecter.rb

@@ -2,6 +2,7 @@ module VagrantPlugins
   module Dotvm
     class ConfigInjecter
 
+      public
       def self.inject(config, vc)
         # General settings
         vc.ssh.forward_x11 = true
@@ -10,20 +11,20 @@ module VagrantPlugins
           vc.vm.define machine_cfg[:nick],
                        primary: machine_cfg[:primary],
                        autostart: machine_cfg[:autostart] do |machine|
-            machine.vm.box      = machine_cfg[:box]
-            machine.vm.hostname = machine_cfg[:name]
-            machine.vm.boot_timeout = machine_cfg[:boot_timeout]
-            machine.vm.box_check_update = machine_cfg[:box_check_update]
-            machine.vm.box_version = machine_cfg[:box_version]
+            machine.vm.box                   = machine_cfg[:box]
+            machine.vm.hostname              = machine_cfg[:name]
+            machine.vm.boot_timeout          = machine_cfg[:boot_timeout]
+            machine.vm.box_check_update      = machine_cfg[:box_check_update]
+            machine.vm.box_version           = machine_cfg[:box_version]
             machine.vm.graceful_halt_timeout = machine_cfg[:graceful_halt_timeout]
-            machine.vm.post_up_message = machine_cfg[:post_up_message]
+            machine.vm.post_up_message       = machine_cfg[:post_up_message]
 
             machine.vm.provider "virtualbox" do |vb|
-              vb.customize ['modifyvm', :id, '--memory', machine_cfg['memory'] ||= 1024]
-              vb.customize ['modifyvm', :id, '--cpus',   machine_cfg['cpus']   ||= 1]
-              vb.customize ['modifyvm', :id, '--cpuexecutioncap', machine_cfg['cpucap'] ||= 100]
-              vb.customize ['modifyvm', :id, '--natdnshostresolver1', 'on']
-              vb.customize ['modifyvm', :id, '--natnet1', machine_cfg['natnet'] ||= '192.168.88.0/24']
+              vb.customize ["modifyvm", :id, "--memory", machine_cfg[:memory]]
+              vb.customize ["modifyvm", :id, "--cpus",   machine_cfg[:cpus]]
+              vb.customize ["modifyvm", :id, "--cpuexecutioncap", machine_cfg[:cpucap]]
+              vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
+              vb.customize ["modifyvm", :id, "--natnet1", machine_cfg["natnet"]]
             end
 
             machine_cfg[:networks].each do |net|
@@ -43,20 +44,28 @@ module VagrantPlugins
                 machine.vm.network net[:net],
                                    guest: net[:guest],
                                    host: net[:host],
-                                   protocol: net[:protocol]                                   
+                                   protocol: net[:protocol]
+              end
+            end
+
+            machine_cfg[:routes].each do |route|
+              machine.vm.provision "shell", run: "always" do |s|
+                s.path       = File.dirname(__FILE__) + "/../../utils/setup_route.sh"
+                s.args       = [route[:destination], route[:gateway]]
+                s.privileged = true
               end
             end
 
             machine_cfg[:provision].each do |provision|
-              machine.vm.provision provision[:type] do |p|
-                if provision[:type] == 'shell'
+              machine.vm.provision provision[:type], run: provision[:run] do |p|
+                if provision[:type] == "shell"
                   p.path           = provision[:path]
                   p.args           = provision[:args]
-                  p.privileged     = provision[:privileged] ||= true
-                elsif provision[:type] == 'file'
+                  p.privileged     = provision[:privileged]
+                elsif provision[:type] == "file"
                   p.source         = provision[:source]
                   p.destination    = provision[:destination]
-                elsif provision[:type] == 'puppet'
+                elsif provision[:type] == "puppet"
                   p.module_path    = provision[:module_path]
                   p.manifest_file  = provision[:manifest_file]
                   p.manifests_path = provision[:manifests_path]
@@ -73,20 +82,20 @@ module VagrantPlugins
             end
 
             machine_cfg[:authorized_keys].each do |key|
-              if key[:type] == 'file'
+              if key[:type] == "file"
                 pubkey = File.readlines(File.expand_path(key[:path])).first.strip
-              elsif key[:type] == 'static'
+              elsif key[:type] == "static"
                 pubkey = key[:key]
               end
 
-              machine.vm.provision 'shell' do |s|
+              machine.vm.provision "shell" do |s|
                 s.path       = File.dirname(__FILE__) + "/../../utils/authorize_key.sh"
                 s.args       = [pubkey]
                 s.privileged = false
               end
             end
 
-            if Vagrant.has_plugin?('vagrant-group')
+            if Vagrant.has_plugin?("vagrant-group")
               vc.group.groups = {} unless vc.group.groups.kind_of?(Hash)
 
               machine_cfg[:groups].each do |group|

data/lib/vagrant-dotvm/configparser.rb

@@ -2,35 +2,26 @@ module VagrantPlugins
   module Dotvm
     class ConfigParser
 
-      DEFAULT_NET     = 'private_network'
-      DEFAULT_NET_TYPE = 'static'
-      DEFAULT_NETMASK = '255.255.255.0'
-      DEFAULT_PROTOCOL = 'tcp'
-      DEFAULT_BOOT_TIMEOUT = 300
-      DEFAULT_BOX_CHECK_UPDATE = true
-      DEFAULT_BOX_VERSION = '>= 0'
-      DEFAULT_GRACEFUL_HALT_TIMEOUT = 60
-
       def initialize(vars = {})
         @vars = vars
       end
 
-
+      private
       def replace_vars(value)
         if value.kind_of?(Hash)
           result = {}
           value.each do |key, val|
-            result[key] = self.replace_vars(val)
+            result[key] = replace_vars(val)
           end
         elsif value.kind_of?(Array)
           result = value.map do |val|
-            self.replace_vars(val)
+            replace_vars(val)
           end
         elsif value.kind_of?(String)
           result = value.dup
 
           @vars.each do |k, v|
-            pattern = '%' + k + '%'
+            pattern = "%#{k}%"
             result.gsub! pattern, v
           end
         elsif !value.respond_to?(:duplicable) or !value.duplicable?
@@ -42,142 +33,155 @@ module VagrantPlugins
         return result
       end
 
-        
+      private
       def parse_machine(machine)
-        return {
-          :nick	      => machine['nick'],
-          :name	      => machine['name'],
-          :box        => machine['box'],
-          :memory     => machine['memory'],
-          :cpus       => machine['cpus'],
-          :cpucap     => machine['cpucap'],
-          :primary    => self.coalesce(machine['primary'], false),
-          :natnet     => machine['natnet'],
-          :networks   => [],
-          :provision  => [],
-          :folders    => [
+        {
+          :nick	                 => machine["nick"],
+          :name	                 => machine["name"],
+          :box                   => machine["box"],
+          :memory                => coalesce(machine["memory"], Defaults::MEMORY),
+          :cpus                  => coalesce(machine["cpus"], Defaults::CPUS),
+          :cpucap                => coalesce(machine["cpucap"], Defaults::CPUCAP),
+          :primary               => coalesce(machine["primary"], false),
+          :natnet                => coalesce(machine["natnet"], Defaults::NATNET),
+          :networks              => [],
+          :routes                => [],
+          :provision             => [],
+          :groups                => [],
+          :authorized_keys       => [],
+          :boot_timeout          => coalesce(machine["boot_timeout"], Defaults::BOOT_TIMEOUT),
+          :box_check_update      => coalesce(machine["box_check_update"], Defaults::BOX_CHECK_UPDATE),
+          :box_version           => coalesce(machine["box_version"], Defaults::BOX_VERSION),
+          :graceful_halt_timeout => coalesce(machine["graceful_halt_timeout"], Defaults::GRACEFUL_HALT_TIMEOUT),
+          :post_up_message       => machine["post_up_message"],
+          :autostart             => coalesce(machine["autostart"], true),
+          :folders               => [
             {
-              :host => '%project.host%',
-              :guest => '%project.guest%',
+              :host     => "%project.host%",
+              :guest    => "%project.guest%",
               :disabled => false,
-              :create => false,
-              :type => nil,
+              :create   => false,
+              :type     => nil,
             }
           ],
-          :groups     => [],
-          :authorized_keys => [],
-          :boot_timeout => self.coalesce(machine['boot_timeout'], DEFAULT_BOOT_TIMEOUT),
-          :box_check_update => self.coalesce(machine['box_check_update'], DEFAULT_BOX_CHECK_UPDATE),
-          :box_version => self.coalesce(machine['box_version'], DEFAULT_BOX_VERSION),
-          :graceful_halt_timeout => self.coalesce(machine['graceful_halt_timeout'], DEFAULT_GRACEFUL_HALT_TIMEOUT),
-          :post_up_message => machine['post_up_message'],
-          :autostart => self.coalesce(machine['autostart'], true),
         }
       end
 
-      
+      private
       def parse_net(net)
-        case net['net']
-        when 'private_network', 'private'
-          nettype = :private_network
-        when 'forwarded_port', 'port'
-          nettype = :forwarded_port
-        when 'public_network', 'public', 'bridged'
-          nettype = :public_network
-        else
-          nettype = DEFAULT_NET
-        end
-        
-        return {
-          :net  => nettype,
-          :type => self.coalesce(net['type'], DEFAULT_NET_TYPE),
-          :ip   => net['ip'],
-          :mask => self.coalesce(net['mask'], net['netmask'], DEFAULT_NETMASK),
-          :interface => net['interface'],
-          :guest => net['guest'],
-          :host => net['host'],
-          :protocol => self.coalesce(net['protocol'], DEFAULT_PROTOCOL),
-          :bridge => net['bridge'],
+        nets = {
+          "private_network" => :private_network,
+          "private"         => :private_network,
+          "public_network"  => :public_network,
+          "public"          => :public_network,
+          "forwarded_port"  => :forwarded_port,
+          "port"            => :forwarded_port,
+        }
+
+        {
+          :net       => nets.has_key?(net["net"]) ? nets[net["net"]] : Defaults::NET,
+          :type      => coalesce(net["type"], Defaults::NET_TYPE),
+          :ip        => net["ip"],
+          :mask      => coalesce(net["mask"], net["netmask"], Defaults::NETMASK),
+          :interface => net["interface"],
+          :guest     => net["guest"],
+          :host      => net["host"],
+          :protocol  => coalesce(net["protocol"], Defaults::PROTOCOL),
+          :bridge    => net["bridge"],
         }
       end
 
-      
-      def parse_provision(prv)
-        return {
-          :type		  => prv['type'],
-          :source         => prv['source'],
-          :destination    => prv['destination'],
-          :path		  => prv['path'],
-          :args           => prv['args'],
-          :module_path    => prv['module_path'],
-          :manifests_path => prv['manifests_path'],
-          :manifest_file  => prv['manifest_file'],
+      private
+      def parse_route(route)
+        {
+          :destination => route["destination"],
+          :gateway     => route["gateway"],
         }
       end
 
+      private
+      def parse_provision(prv)
+        {
+          :type		  => prv["type"],
+          :source         => prv["source"],
+          :destination    => prv["destination"],
+          :path		  => prv["path"],
+          :args           => prv["args"],
+          :module_path    => prv["module_path"],
+          :manifests_path => prv["manifests_path"],
+          :manifest_file  => prv["manifest_file"],
+          :privileged     => prv["privileged"].nil? ? true : prv["privileged"],
+          :run            => prv["run"],
+        }
+      end
 
+      private
       def parse_folder(folder)
-        return {
-          :host  => folder['host'],
-          :guest => folder['guest'],
-          :disabled => self.coalesce(folder['disabled'], false),
-          :create => self.coalesce(folder['create'], false),
-          :type => folder['type'],
+        {
+          :host     => folder["host"],
+          :guest    => folder["guest"],
+          :disabled => coalesce(folder["disabled"], false),
+          :create   => coalesce(folder["create"], false),
+          :type     => folder["type"],
         }
       end
 
-
+      private
       def parse_authorized_key(key)
-        return {
-          :type => key['type'],
-          :path => key['path'],
-          :key => key['key'],
+        {
+          :type => key["type"],
+          :path => key["path"],
+          :key  => key["key"],
         }
       end
 
-      
+      public
       def parse(yaml)
         config = {
           :machines => []
         }
 
-        yaml['machines'].each do |machine|
+        yaml["machines"].each do |machine|
           item = parse_machine(machine)
 
-          machine['networks'] and machine['networks'].each do |net|
-            item[:networks] << self.parse_net(net)
+          machine["networks"].to_a.each do |net|
+            item[:networks] << parse_net(net)
           end
 
-          machine['provision'] and machine['provision'].each do |prv|
-            item[:provision] << self.parse_provision(prv)
+          machine["routes"].to_a.each do |route|
+            item[:routes] << parse_route(route)
           end
 
-          machine['shared_folders'] and machine['shared_folders'].each do |folder|
-            item[:folders] << self.parse_folder(folder)
+          machine["provision"].to_a.each do |prv|
+            item[:provision] << parse_provision(prv)
           end
 
-          machine['groups'] and machine['groups'].each do |group|
+          machine["shared_folders"].to_a.each do |folder|
+            item[:folders] << parse_folder(folder)
+          end
+
+          machine["groups"].to_a.each do |group|
             item[:groups] << group
           end
 
-          machine['authorized_keys'].to_a.each do |key|
-            item[:authorized_keys] << self.parse_authorized_key(key)
+          machine["authorized_keys"].to_a.each do |key|
+            item[:authorized_keys] << parse_authorized_key(key)
           end
 
           config[:machines] << item
         end
 
-        return self.replace_vars(config)
+        replace_vars(config)
       end
 
-
+      private
       def coalesce(*args)
         args.each do |val|
           next if val.nil?
           return val
         end
       end
-      
+
     end
   end
 end

data/lib/vagrant-dotvm/defaults.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Dotvm
+    class Defaults
+      MEMORY                = 1024
+      CPUS                  = 1
+      CPUCAP                = 100
+      NATNET                = "192.168.88.0/24"
+      NET                   = :private_network
+      NET_TYPE              = "static"
+      NETMASK               = "255.255.255.0"
+      PROTOCOL              = "tcp"
+      BOOT_TIMEOUT          = 300
+      BOX_CHECK_UPDATE      = true
+      BOX_VERSION           = ">= 0"
+      GRACEFUL_HALT_TIMEOUT = 60
+    end # Defaults
+  end # Dotvm
+end # VagrantPlugins

data/lib/vagrant-dotvm/dotvm.rb

@@ -10,7 +10,7 @@ module VagrantPlugins
         @path = path
       end
 
-
+      private
       def get_configs()
         configs = []
 
@@ -33,9 +33,9 @@ module VagrantPlugins
         return configs
       end
 
-
+      public
       def inject(vc)
-        configs = self.get_configs()
+        configs = get_configs()
 
         configs.each do |config|
           ConfigInjecter.inject(config, vc)

data/lib/vagrant-dotvm/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Dotvm
-    VERSION = "0.14.0"
+    VERSION = "0.15.0"
   end
 end

data/utils/setup_route.sh

@@ -0,0 +1,5 @@
+DESTINATION="$1"
+GATEWAY="$2"
+
+while ip route delete "$DESTINATION" ; do :; done >/dev/null 2>&1
+ip route replace "$DESTINATION" via "$GATEWAY"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-dotvm
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Krzysztof Magosa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,10 +62,12 @@ files:
 - lib/vagrant-dotvm.rb
 - lib/vagrant-dotvm/configinjecter.rb
 - lib/vagrant-dotvm/configparser.rb
+- lib/vagrant-dotvm/defaults.rb
 - lib/vagrant-dotvm/dotvm.rb
 - lib/vagrant-dotvm/plugin.rb
 - lib/vagrant-dotvm/version.rb
 - utils/authorize_key.sh
+- utils/setup_route.sh
 - vagrant-dotvm.gemspec
 homepage: http://github.com/krzysztof-magosa/vagrant-dotvm
 licenses: