knife-stackbuilder 0.5.9 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ab807fc026606708f650e207c681ea3ffb82486
-  data.tar.gz: 71a6b26ab5974d2e1c117f04da246f150dcc4375
+  metadata.gz: 4f785f195082e19cce38b6ed050c7c372058cc91
+  data.tar.gz: 1bffb5f8a0834b0b94ed27b2df4379b7b556e71e
 SHA512:
-  metadata.gz: 53bac33ce0fe0a52524d8dbe36d18aadd34cdecd0a0bbe66cd2bf2ff393f2741cf08f745cde95c34c962e8a6db1e56ebae016a182ae199157bb94d2014985577
-  data.tar.gz: 52a0c878e71ee0f512fa3eb8b6213aa03a24a7772e9e2bc2c99dfc0324168998e2f96b6f6878de2c6040ae197ed22ce84bcc58414269d5a24c08c2b343e00507
+  metadata.gz: e36a47c1b0745433163df25eda03f5266979a3629f5b4d999d50948c576cbc11c8c72df6bcd2f79e5f5d8fc48e30d04fcb8214ebb5a5ead5e9962cfb0429c0f1
+  data.tar.gz: 8b1cf1c3387e9d8465f562abf578c082275bac61d06266bc6c0d73c2b78c6f1b2058ae4b742fa938b6e36d87b798ef0f85a7d4fd031620e1d8f331a21edfd766

data/lib/chef/knife/stack_build.rb

@@ -56,7 +56,7 @@ class Chef
                 repo_path = getConfig(:repo_path)
                 environment = getConfig(:environment) || '_default'
 
-                stack_id = getConfig(:stack_id) || ENV['STACK_ID']
+                stack_id = getConfig(:stack_id) || ENV['STACK_ID'] || environment
                 stack_overrides = getConfig(:overrides) || ENV['STACK_OVERRIDES']
 
                 stack_file = name_args.first

data/lib/chef/knife/stack_delete.rb

@@ -13,8 +13,7 @@ class Chef
 
             option :stack_id,
                :long => "--stack-id STACK_ID",
-               :description => "The ID of the stack to delete.",
-               :required => true
+               :description => "The ID of the stack to delete."
 
             option :repo_path,
                :long => "--repo_path REPO_PATH",
@@ -25,7 +24,7 @@ class Chef
             def run
                 StackBuilder::Common::Config.logger.level = Chef::Log.logger.level
 
-                environment = getConfig(:environment) || '_default'
+                environment = getConfig(:environment) || '_default'                
                 stack_file = name_args.first
 
                 if stack_file=~/[-_+=.0-9a-zA-Z]+/
@@ -40,7 +39,7 @@ class Chef
                 stack = StackBuilder::Stack::Stack.new(
                     StackBuilder::Chef::NodeProvider.new(getConfig(:repo_path), environment),
                     stack_file,
-                    getConfig(:stack_id) )
+                    getConfig(:stack_id) || ENV['STACK_ID'] || environment )
 
                 stack.destroy
             end

data/lib/stackbuilder.rb

@@ -12,12 +12,14 @@ require 'fileutils'
 require 'tmpdir'
 require 'tempfile'
 require "stringio"
+require 'set'
 require 'json'
 require 'timeout'
 require 'openssl'
-require "net/ssh"
-require "net/ssh/multi"
-require "highline/import"
+require 'net/ssh'
+require 'net/ssh/multi'
+require 'ipaddr'
+require 'highline/import'
 
 require 'chef'
 require 'chef/knife'

data/lib/stackbuilder/chef/stack_container_node.rb

@@ -39,8 +39,8 @@ module StackBuilder::Chef
                 ipaddress = node.attributes['ipaddress']
             end
 
-            ssh = ssh_create(ipaddress, target.ssh_user,
-                target.ssh_password.nil? ? target.ssh_identity_file : target.ssh_password)
+            ssh_user, ssh_password, ssh_identity_file = target.get_ssh_credentials(target_node_instance)
+            ssh = ssh_create(ipaddress, ssh_user, ssh_password || ssh_identity_file)
 
             image_exists = @name==ssh_exec!(ssh, "docker images | awk '$1==\"@name\" { print $1 }'")[:out].strip
 

data/lib/stackbuilder/chef/stack_generic_node.rb

@@ -6,34 +6,65 @@ module StackBuilder::Chef
 
     class GenericNodeManager < StackBuilder::Chef::NodeManager
 
+        def initialize(id, node_config, repo_path, environment, static_ips)
+
+            super(id, node_config, repo_path, environment)
+
+            @static_ips = static_ips
+            unless @static_ips.nil?
+                get_stack_node_resources
+                @nodes.each { |n| @static_ips.delete_if { |ip| ip.split('/').first==n["ipaddress"] } }
+            end
+        end
+
         def create_vm(index, name, knife_config)
 
+            pre_create = knife_config['pre_create']
+            pre_create.each { |c| self.run_knife_cmd(name, knife_config, c) } unless pre_create.nil?
+
             create_class_name = knife_config['create']['class']
             raise ArgumentError, "Knife plugin's server 'create' class name not provided." \
                 if create_class_name.nil?
 
             knife_cmd = eval(create_class_name + '.new')
 
-            if knife_config['create'].has_key?('name_key')
-                name_key = knife_config['create']['name_key']
+            create_options = knife_config['create']
+
+            if create_options.has_key?('name_key')
+                name_key = create_options['name_key']
                 knife_cmd.config[name_key.to_sym] = name
             else
                 knife_cmd.name_args = [ name ]
             end
 
-            if knife_config['create'].has_key?('pool_key')
+            if create_options.has_key?('pool_key')
 
-                pool_key = knife_config['create']['pool_key']
+                pool_key = create_options['pool_key']
 
                 placement_pools = knife_config['placement_pools']
                 raise ArgumentError, "Knife plugin 'placement_pools' list was not provided." \
                     if placement_pools.nil?
 
                 knife_cmd.config[pool_key.to_sym] = placement_pools[index % placement_pools.size]
-            end            
+            end
+
+            self.config_knife(name, knife_cmd, knife_config['create']['options'] || { })
+            self.config_knife(name, knife_cmd, knife_config['options'] || { })
+
+            if create_options.has_key?('static_ip_key') && !@static_ips.nil?
+
+                static_ip = @static_ips.shift
+                raise Common::StackBuilder::StackBuilderError, "Static IP pool is empty." \
+                    if static_ip.nil?
+
+                static_ip_key = create_options['static_ip_key']
+                ip_data = knife_config['create']['options'][static_ip_key]
+                static_ip += "#{ip_data}" unless ip_data.nil?
+                
+                knife_cmd.config[static_ip_key.to_sym] = static_ip
+            end
 
-            config_knife(knife_cmd, knife_config['create']['options'] || { })
-            config_knife(knife_cmd, knife_config['options'] || { })
+            @logger.info("Executing knife to create VM: #{knife_cmd} / #{knife_cmd.name_args} / #{knife_cmd.config}")
 
             if knife_config['create']['synchronized']
                 @@sync ||= Mutex.new
@@ -43,6 +74,35 @@ module StackBuilder::Chef
             else
                 run_knife_forked(knife_cmd)
             end
+
+            post_create = knife_config['post_create']
+            post_create.each { |c| self.run_knife_cmd(name, knife_config, c) } unless post_create.nil?
+        end
+
+        def run_knife_cmd(name, knife_config, knife_command)
+
+            class_name = knife_command['class']
+            raise ArgumentError, "Knife command action class name not provided: #{knife_command}" \
+                if class_name.nil?
+
+            knife_cmd = eval(class_name + '.new')
+
+            if knife_command.has_key?('name_key')
+                name_key = knife_command['name_key']
+                knife_cmd.config[name_key.to_sym] = name
+            else
+                knife_cmd.name_args = [ name ]
+            end
+
+            name_args = knife_command['args'].to_s
+            knife_cmd.name_args += name_args.start_with?('"') ?
+                name_args.split(/\"\s+\"/).collect { |s| s.gsub(/^\"|\"$/, '') } : name_args.split unless name_args.nil?
+
+            self.config_knife(name, knife_cmd, knife_command['options'] || { })
+            self.config_knife(name, knife_cmd, knife_config['options'] || { })
+
+            @logger.info("Executing knife: #{knife_cmd} / #{knife_cmd.name_args} / #{knife_cmd.config}")
+            run_knife_forked(knife_cmd)
         end
 
         def delete_vm(name, knife_config)
@@ -62,11 +122,13 @@ module StackBuilder::Chef
                 knife_cmd.name_args = [ name ]
             end
 
-            config_knife(knife_cmd, knife_config['delete']['options'] || { })
-            config_knife(knife_cmd, knife_config['options'] || { })
+            self.config_knife(name, knife_cmd, knife_config['delete']['options'] || { })
+            self.config_knife(name, knife_cmd, knife_config['options'] || { })
 
             knife_cmd.config[:yes] = true
 
+            @logger.info("Executing knife to delete VM: #{knife_cmd} / #{knife_cmd.name_args} / #{knife_cmd.config}")
+
             if knife_config['delete']['synchronized']
                 @@sync ||= Mutex.new
                 @@sync.synchronize {

data/lib/stackbuilder/chef/stack_node_manager.rb

@@ -14,9 +14,7 @@ module StackBuilder::Chef
         attr_accessor :run_list
         attr_accessor :run_on_event
 
-        attr_accessor :ssh_user
-        attr_accessor :ssh_password
-        attr_accessor :ssh_identity_file
+        SSH_CREDENTIAL_KEYS = Set.new(['ssh_user', 'ssh_password', 'identity_file'])
 
         def initialize(id, node_config, repo_path, environment)
 
@@ -32,12 +30,27 @@ module StackBuilder::Chef
             @run_on_event = node_config['run_on_event']
 
             @knife_config = node_config['knife']
-            if @knife_config && @knife_config.has_key?('options')
 
-                raise ArgumentError, 'An ssh user needs to be provided for bootstrap and knife ssh.' \
+            @env_key_file = "#{repo_path}/secrets/#{environment}"
+            @env_key_file = nil unless File.exist?(@env_key_file)
+        end
+
+        def get_name
+            @name
+        end
+
+        def get_scale
+            get_stack_node_resources
+        end
+
+        def get_ssh_credentials(name)
+
+            if @ssh_user.nil?
+
+                raise ArgumentError, 'An ssh user is required to create ssh sessions.' \
                     unless @knife_config['options'].has_key?('ssh_user')
 
-                raise ArgumentError, 'An ssh key file or password must be provided for knife to be able ssh to a node.' \
+                raise ArgumentError, 'An ssh key file or password is required to create ssh sessions.' \
                     unless @knife_config['options'].has_key?('identity_file') ||
                        @knife_config['options'].has_key?('ssh_password')
 
@@ -47,16 +60,7 @@ module StackBuilder::Chef
                 @ssh_identity_file.gsub!(/~\//, Dir.home + '/') unless @ssh_identity_file.nil?
             end
 
-            @env_key_file = "#{repo_path}/secrets/#{environment}"
-            @env_key_file = nil unless File.exist?(@env_key_file)
-        end
-
-        def get_name
-            @name
-        end
-
-        def get_scale
-            get_stack_node_resources
+            [ @ssh_user, @ssh_password, @ssh_identity_file ]
         end
 
         def node_attributes
@@ -191,17 +195,30 @@ module StackBuilder::Chef
             raise StackBuilder::Common::NotImplemented, 'HostNodeManager.delete_vm'
         end
 
-        def config_knife(knife_cmd, options)
+        def config_knife(name, knife_cmd, options)
 
             options.each_pair do |k, v|
 
-                arg = k.gsub(/-/, '_')
+                unless SSH_CREDENTIAL_KEYS.include?(k)
 
-                # Fix issue where '~/' is not expanded to home dir
-                v.gsub!(/~\//, Dir.home + '/') if arg.end_with?('_dir') && v.start_with?('~/')
+                    arg = k.gsub(/-/, '_')
 
-                knife_cmd.config[arg.to_sym] = v
+                    # Fix issue where '~/' is not expanded to home dir
+                    v.gsub!(/~\//, Dir.home + '/') if arg.end_with?('_dir') && v.start_with?('~/')
+
+                    knife_cmd.config[arg.to_sym] = v
+                end
             end
+
+            unless @env_key_file.nil?
+                env_key = IO.read(@env_key_file)
+                knife_cmd.config[:secret] = env_key
+            end
+
+            ssh_user, ssh_password, ssh_identity_file = self.get_ssh_credentials(name)
+            knife_cmd.config[:ssh_user] = ssh_user
+            knife_cmd.config[:ssh_password] = ssh_password unless ssh_password.nil?
+            knife_cmd.config[:identity_file] = ssh_identity_file unless ssh_identity_file.nil?
         end
 
         private
@@ -213,47 +230,18 @@ module StackBuilder::Chef
             @nodes.size
         end
 
-        def knife_ssh(name, cmd)
-
-            knife_config_options = @knife_config['options'] || { }
-
-            sudo = knife_config_options['sudo'] ? 'sudo -i su -c ' : ''
-
-            ssh_cmd = "TMPFILE=`mktemp` && " +
-                "echo -e \"#{cmd.gsub(/\"/, "\\\"").gsub(/\$/, "\\$").gsub(/\`/, '\\' + '\`')}\" > $TMPFILE && " +
-                "chmod 0744 $TMPFILE && " +
-                "#{sudo}$TMPFILE && " +
-                "rm $TMPFILE"
-
-            knife_cmd = Chef::Knife::Ssh.new
-            knife_cmd.name_args = [ "name:#{name}", ssh_cmd ]
-            knife_cmd.config[:attribute] = knife_config_options['ip_attribute'] || 'ipaddress'
-
-            config_knife(knife_cmd, knife_config_options)
-
-            if @logger.info? || @logger.debug?
-
-                output = StackBuilder::Common::TeeIO.new($stdout)
-                error = StackBuilder::Common::TeeIO.new($stderr)
-
-                @logger.info("Running '#{cmd}' on node 'name:#{name}'.")
-                run_knife(knife_cmd, output, error)
-            else
-                run_knife(knife_cmd)
-            end
-        end
-
         def node_search(search_query, timeout = 0)
 
             query = Chef::Search::Query.new
             escaped_query = URI.escape(search_query, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
 
             if timeout>0
-                @logger.info("Waiting '#{search_query}' to return results.")
+                @logger.info("#{@name} - Waiting '#{search_query}' to return results.")
                 results = Timeout::timeout(timeout) {
 
                     while true do
                         results = query.search('node', escaped_query, nil, 0, 999999)
+                        sleep 5
                         return results if results[0].size>0
                     end
                 }
@@ -264,5 +252,26 @@ module StackBuilder::Chef
             results
         end
 
+        def knife_ssh(name, cmd)
+
+            knife_config = @knife_config['options'] || { }
+
+            sudo = knife_config['sudo'] ? 'sudo -i su -c ' : ''
+
+            ssh_cmd = "TMPFILE=`mktemp` && " +
+                "echo -e \"#{cmd.gsub(/\"/, "\\\"").gsub(/\$/, "\\$").gsub(/\`/, '\\' + '\`')}\" > $TMPFILE && " +
+                "chmod 0744 $TMPFILE && " +
+                "#{sudo}$TMPFILE && " +
+                "rm $TMPFILE"
+
+            knife_cmd = Chef::Knife::Ssh.new
+            knife_cmd.name_args = [ "name:#{name}", ssh_cmd ]
+            knife_cmd.config[:attribute] = knife_config['ip_attribute'] || 'ipaddress'
+
+            self.config_knife(name, knife_cmd, knife_config)
+
+            @logger.info("#{@name} - Running '#{cmd}' on node 'name:#{name}'.")
+            run_knife(knife_cmd)
+        end
     end
 end

data/lib/stackbuilder/chef/stack_provider.rb

@@ -46,6 +46,8 @@ module StackBuilder::Chef
                 stack['chef']['knife_config'].each { |k,v| Chef::Config[:knife][k.to_sym] = v } \
                     if stack['chef'].has_key?('knife_config')
             end
+
+            @static_ips = stack['static_ips']
         end
 
         def get_env_vars
@@ -77,7 +79,7 @@ module StackBuilder::Chef
                     end
 
                 elsif knife_config.has_key?('create')
-                    return StackBuilder::Chef::GenericNodeManager.new(@id, node_config, @repo_path, @environment)
+                    return StackBuilder::Chef::GenericNodeManager.new(@id, node_config, @repo_path, @environment, @static_ips)
 
                 else
                     return StackBuilder::Chef::NodeManager.new(@id, node_config, @repo_path, @environment)

data/lib/stackbuilder/chef/stack_vagrant_node.rb

@@ -6,6 +6,37 @@ module StackBuilder::Chef
 
     class VagrantNodeManager < StackBuilder::Chef::NodeManager
 
+        VAGRANT_PROVIDER = 'virtualbox'
+        VAGRANT_DIR = File.join(Dir.home, '/.vagrant')
+        INSECURE_KEY_PATH = "#{VAGRANT_DIR}/insecure_key"
+
+        def vagrant_version
+            @@vagrant_version ||= begin
+                `vagrant -v`[/Vagrant\s+([0-9\.]+)/, 1]
+            rescue Exception => msg
+                raise StackBuilder::Common::StackBuilderError, "Unable to locate vagrant."                
+            end
+        end
+
+        def get_ssh_credentials(name)
+
+            ssh_user = @knife_config['options']['ssh_user'] || 'vagrant'
+            ssh_identity_file = @knife_config['options']['identity_file']
+
+            if ssh_identity_file.nil?
+
+                provider = @knife_config['options']['provider'] || VAGRANT_PROVIDER
+                vagrant_dir = @knife_config['options']['vagrant_dir'] || VAGRANT_DIR
+
+                ssh_identity_file = ( vagrant_version<'1.7' ? INSECURE_KEY_PATH : 
+                    "#{vagrant_dir}/#{name}/.vagrant/machines/default/#{provider}/private_key" )
+            else
+                ssh_identity_file.gsub!(/~\//, Dir.home + '/')
+            end
+
+            [ ssh_user, nil, ssh_identity_file ]
+        end
+
         def create_vm(index, name, knife_config)
 
             handle_vagrant_box_additions(name, knife_config)
@@ -18,8 +49,8 @@ module StackBuilder::Chef
             knife_cmd.config[:distro] = 'chef-full'
             knife_cmd.config[:template_file] = false
 
-            knife_cmd.config[:vagrant_dir] = File.join(Dir.home, '/.vagrant')
-            knife_cmd.config[:provider] = 'virtualbox'
+            knife_cmd.config[:vagrant_dir] = VAGRANT_DIR
+            knife_cmd.config[:provider] = VAGRANT_PROVIDER
             knife_cmd.config[:memsize] = 1024
             knife_cmd.config[:subnet] = '192.168.67.0/24'
             knife_cmd.config[:port_forward] = { }
@@ -30,7 +61,10 @@ module StackBuilder::Chef
             knife_cmd.config[:ssh_user] = 'vagrant'
             knife_cmd.config[:ssh_port] = '22'
 
-            config_knife(knife_cmd, knife_config['options'] || { })
+            self.config_knife(name, knife_cmd, knife_config['options'] || { })
+
+            # Let vagrant use auto-generated private key for ssh during bootstrap
+            knife_cmd.config[:identity_file] = nil if vagrant_version>'1.7'
 
             ip_address = knife_cmd.config[:ip_address]
             knife_cmd.config[:ip_address] = ip_address[/(\d+\.\d+\.\d+\.)/, 1] + \
@@ -45,13 +79,10 @@ module StackBuilder::Chef
 
         def delete_vm(name, knife_config)
 
-            puts "deleting #{name}"
-            exit 1
-
             knife_cmd = Chef::Knife::VagrantServerDelete.new
             knife_cmd.name_args = [ name ]
             knife_cmd.config[:yes] = true
-            knife_cmd.config[:vagrant_dir] = File.join(Dir.home, '/.vagrant')
+            knife_cmd.config[:vagrant_dir] = VAGRANT_DIR
 
             @@sync ||= Mutex.new
             @@sync.synchronize {
@@ -76,12 +107,31 @@ module StackBuilder::Chef
             end
         end
 
+        def config_knife(name, knife_cmd, options)
+
+            super(name, knife_cmd, options)
+
+            # Add ohai plugin to change the ohai ipaddress 
+            # value to the non NAT'ed eth1 interface. This
+            # is required so you can SSH into vagrant VMs
+            # via knife ssh
+            ohai_plugin_resource = File.expand_path('../../resources/vagrant.rb', __FILE__)
+
+            knife_cmd.config[:vagrant_config] = \
+                "config.vm.provision \"file\", source: \"#{ohai_plugin_resource}\", destination: \"~/vagrant.rb\"::" +
+                'config.vm.provision "shell", inline: "mkdir -p /etc/chef/ohai_plugins"::' +
+                'config.vm.provision "shell", inline: "mv /home/vagrant/vagrant.rb /etc/chef/ohai_plugins"::' +
+                'config.vm.provision "shell", inline: \'echo {\"primary_nic\":\"eth1\"} > /etc/chef/ohai_plugins/vagrant.json\'::' +
+                (knife_cmd.config[:vagrant_config] || '')
+        end
+
         def handle_vagrant_box_additions(name, knife_config)
 
             # Create add-on provider specific infrastructure
             knife_options = knife_config['options']
             provider = knife_options['provider']
 
+            # Create disks for vagrant vms on vmware if requested
             if !provider.nil? && provider.start_with?('vmware')
 
                 vmx_customize = knife_options['vmx_customize']

data/lib/stackbuilder/common/config.rb

@@ -4,7 +4,7 @@ module StackBuilder::Common
     
     class Config
 
-        QUERY_TIMEOUT = 60
+        QUERY_TIMEOUT = 300
         CACHE_TIMEOUT = 60
 
         class << self

data/lib/stackbuilder/common/helpers.rb

@@ -4,6 +4,8 @@ module StackBuilder::Common
 
     module Helpers
 
+        MAGIC_VARS = Set.new(%w(env my))
+
         #
         # Returns whether platform is a nix OS
         #
@@ -48,7 +50,8 @@ module StackBuilder::Common
                             yield(job)
                             Marshal.dump([stdout.string, stderr.string], write)
                         rescue Exception => msg
-                            Marshal.dump([stdout.string, stderr.string, msg], write)
+                            StackBuilder::Common::Config.logger.debug("Exception in forked job: #{msg}\n" + msg.backtrace.join("\n\t"))
+                            Marshal.dump([stdout.string, stderr.string, StackBuilder::Common::StackBuilderError.new(msg.to_s) ], write)
                         ensure
                             $stdout = previous_stdout
                             $stderr = previous_stderr
@@ -91,7 +94,7 @@ module StackBuilder::Common
         def load_yaml(file, env_vars, my = nil)
 
             yaml = YAML.load_file(file)
-            eval_map_values(yaml, env_vars, file, my)
+            eval_map_values(yaml, env_vars, file, my || yaml)
         end
 
         #
@@ -104,21 +107,11 @@ module StackBuilder::Common
 
             if v.is_a?(String)
 
-                if v=~/#\{.*\}/
-                    begin
-                        return eval("\"#{v.gsub(/\"/, "\\\"")}\"")
-
-                    rescue Exception => msg
-
-                        StackBuilder::Common::Config.logger.debug( "Error evaluating configuration " +
-                            "variable '#{v}': #{msg}\nenv = #{env}\nmy = #{my}")
+                v = eval("\"#{v.gsub(/\"/, "\\\"")}\"") if v=~/#\{.*\}/
 
-                        return v
-                    end
-
-                elsif v.start_with?('<<')
+                if v.start_with?('<<')
 
-                    k1 = v[/<<(\w*)[\*\$\+]/,1]
+                    k1 = v[/<<(\w*)[\*\$\@\+]/,1]
                     env_val = k1.nil? || k1.empty? ? nil : ENV[k1]
 
                     i = k1.length + 3
@@ -144,27 +137,45 @@ module StackBuilder::Common
                             end
                             return v
 
+                        when '@'
+                            if env_val.nil?
+                                tuple = k2.split(':')
+                            else
+                                tuple = env_val.split(':')
+                            end
+
+                            ipaddress = IPAddr.new(tuple[0])                            
+                            num_ips, cidr_mask = tuple[1].split('/')
+
+                            ipaddresses = [ ipaddress ]
+                            ipaddresses += (0..num_ips.to_i-2).to_a.collect { |i| ipaddress = ipaddress.succ }
+                            return ipaddresses.collect { |i| i.to_s + (cidr_mask.nil? ? '' : "/#{cidr_mask}") }
+
                         when '+'
-                            lookup_keys = (env_val || k2).split(/[\[\]]/).reject { |k| k.empty? }
+                            lookup_keys = (env_val || k2).split(/[\[\]']/).reject { |k| k.empty? }
 
                             key = lookup_keys.shift
-                            include_file = key.start_with?('/') || key.nil? ? key : File.expand_path('../' + key, file)
+                            if MAGIC_VARS.include?(key)
+                                v = eval(key + lookup_keys.collect { |v| "['#{v}']" }.join)
+                            else
+                                include_file = key.start_with?('/') || key.nil? ? key : File.expand_path('../' + key, file)
 
-                            begin
-                                yaml = load_yaml(include_file, env, my)
+                                begin
+                                    yaml = load_yaml(include_file, env, my)
 
-                                return lookup_keys.empty? ? yaml
-                                    : eval('yaml' + lookup_keys.collect { |v| "['#{v}']" }.join)
+                                    return lookup_keys.empty? ? yaml
+                                        : eval('yaml' + lookup_keys.collect { |v| "['#{v}']" }.join)
 
-                            rescue Exception => msg
-                                puts "ERROR: Unable to include referenced data '#{v}'."
-                                raise msg
+                                rescue Exception => msg
+                                    puts "ERROR: Unable to include referenced data '#{v}'."
+                                    raise msg
+                                end
                             end
-                        else
-                            return v
                     end
                 end
 
+                return v
+
             elsif v.is_a?(Hash)
 
                 new_keys = { }
@@ -189,6 +200,13 @@ module StackBuilder::Common
             end
 
             v
+
+        rescue Exception => msg
+
+            StackBuilder::Common::Config.logger.debug( "Error evaluating configuration " +
+                "variable '#{v}': #{msg}\nenv = #{env}\nmy = #{my}")
+
+            v
         end
 
         # 
@@ -375,6 +393,15 @@ module StackBuilder::Common
         #
         def run_knife(knife_cmd, output = StringIO.new, error = StringIO.new)
 
+            logger = StackBuilder::Common::Config.logger
+            if logger.info? || logger.debug?
+                output = StackBuilder::Common::TeeIO.new($stdout)
+                error = StackBuilder::Common::TeeIO.new($stderr)
+            else
+                output = StringIO.new
+                error = StringIO.new
+            end
+
             knife_cmd.ui = Chef::Knife::UI.new(output, error, STDIN, knife_cmd.config) \
                 unless output.nil? && error.nil?
 

data/lib/stackbuilder/resources/vagrant.rb

@@ -0,0 +1,27 @@
+Ohai.plugin(:Vboxipaddress) do
+
+    provides "ipaddress"
+    depends "ipaddress", "network/interfaces", "virtualization/system", "etc/passwd"
+
+    Chef::Log.info("Running Vagrant plugin to reset node ipaddress attribute.")
+
+    if File.exist?('/etc/chef/ohai_plugins/vagrant.json')
+        vagrant = JSON.parse(IO.read('/etc/chef/ohai_plugins/vagrant.json'))
+
+        collect_data(:default) do
+            if virtualization["system"] == "vbox" || virtualization["system"] == "vmware"
+                if etc["passwd"].any? { |k,v| k == "vagrant"}
+                    primary_nic = vagrant["primary_nic"]
+                    if primary_nic && network["interfaces"][primary_nic]
+                        network["interfaces"][primary_nic]["addresses"].each do |ip, params|
+                            if params['family'] == ('inet')
+                                Chef::Log.info("Setting node ipaddress attribute to: #{ip}")
+                                ipaddress ip
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/stackbuilder/stack/node_task.rb

@@ -9,6 +9,7 @@ module StackBuilder::Stack
         attr_reader :name
 
         attr_accessor :scale
+        attr_accessor :max_scale
         attr_accessor :prev_scale
         attr_accessor :sync
 
@@ -38,7 +39,7 @@ module StackBuilder::Stack
             @counter = 0
             
             @name = node_config['node']
-            @attributes = (node_config.has_key?('attributes') ? node_config['attributes'] : { })
+            @attributes = node_config['attributes'] || { }
 
             case node_config['sync']
                 when "first"
@@ -51,10 +52,11 @@ module StackBuilder::Stack
 
             current_scale = manager.get_scale
             if current_scale==0
-                @scale = (node_config.has_key?("scale") ? node_config["scale"] : 1)
+                @scale = node_config["scale"] || 1
             else
                 @scale = current_scale
             end
+            @max_scale = node_config["max_scale"] || @scale
 
             raise ArgumentError, "The scale for node \"#{@name}\" must be greater than 0." if @scale < 1
             @prev_scale = @scale

data/lib/stackbuilder/stack/stack.rb

@@ -104,7 +104,13 @@ module StackBuilder::Stack
                 raise StackBuilder::Common::StackBuilderError, "Invalid node name \"#{name}'\"." if node.nil?
 
                 unless scale.nil?
-                    raise ArgumentError, "The scale for node \"#{@name}\" must be greater than 0." if scale < 1
+                    raise ArgumentError, \
+                        "The scale for node \"#{node.name}\" must be greater than 0." \
+                        if scale < 1
+                    raise ArgumentError, \
+                        "The scale for node \"#{node.name}\" cannot be greater than #{node.max_scale}." \
+                        if scale > node.max_scale
+                    
                     node.scale = scale
                 end
             end

data/lib/stackbuilder/version.rb

@@ -2,7 +2,7 @@
 
 module Knife
     module StackBuilder
-        VERSION = "0.5.9"
+        VERSION = "0.6.0"
         MAJOR, MINOR, TINY = VERSION.split('.')
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-stackbuilder
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.6.0
 platform: ruby
 authors:
 - Mevan Samaratunga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-14 00:00:00.000000000 Z
+date: 2015-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -131,6 +131,7 @@ files:
 - lib/stackbuilder/resources/Environment.rb.erb
 - lib/stackbuilder/resources/Stack.yml.erb
 - lib/stackbuilder/resources/openssl.cnf
+- lib/stackbuilder/resources/vagrant.rb
 - lib/stackbuilder/stack/node_manager.rb
 - lib/stackbuilder/stack/node_provider.rb
 - lib/stackbuilder/stack/node_task.rb
@@ -155,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Knife Stackbuilder plugin