beaker 2.18.3 → 2.19.0

data/spec/beaker/hypervisor/docker_spec.rb

@@ -205,7 +205,8 @@ module Beaker
         ENV['DOCKER_HOST'] = nil
         docker.provision
         hosts.each do |host|
-          expect( docker ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\n192.0.2.1\tvm1\n192.0.2.1\tvm2\n192.0.2.1\tvm3\n" ).once
+          expect( docker ).to receive( :get_domain_name ).with( host ).and_return( 'labs.lan' )
+          expect( docker ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\n192.0.2.1\tvm1.labs.lan vm1\n192.0.2.1\tvm2.labs.lan vm2\n192.0.2.1\tvm3.labs.lan vm3\n" ).once
         end
         docker.hack_etc_hosts( hosts, options )
       end

data/spec/beaker/hypervisor/solaris_spec.rb

@@ -22,6 +22,7 @@ module Beaker
         expect( Command ).to receive( :new ).with("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}/#{spath}@#{snapshot}").once
         expect( Command ).to receive( :new ).with("sudo /sbin/zoneadm -z #{vm_name} boot").once
       end
+      allow_any_instance_of(Host).to receive(:close)
 
       solaris.provision
     end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -143,7 +143,8 @@ EOF
     it "can generate a new /etc/hosts file referencing each host" do
 
       @hosts.each do |host|
-        expect( vagrant ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1\nip.address.for.vm2\tvm2\nip.address.for.vm3\tvm3\n" ).once
+        expect( vagrant ).to receive( :get_domain_name ).with( host ).and_return( 'labs.lan' )
+        expect( vagrant ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1.labs.lan vm1\nip.address.for.vm2\tvm2.labs.lan vm2\nip.address.for.vm3\tvm3.labs.lan vm3\n" ).once
       end
 
       vagrant.hack_etc_hosts( @hosts, options )

data/spec/beaker/logger_spec.rb

@@ -203,6 +203,45 @@ module Beaker
           it( 'errors' )        { info_logger.error 'ERROR!'      }
         end
       end
+
+      context 'SUT output logging' do
+
+        context 'host output logging' do
+          subject( :host_output ) { Logger.new( my_io,
+                                              :log_level => :verbose,
+                                              :quiet     => true,
+                                              :color     => true )}
+
+          it 'should output GREY when @color is set to true' do
+            colorized_logger = host_output
+
+            expect( my_io ).to receive( :print ).with "\e[01;30m"
+            expect( my_io ).to receive( :print )
+            expect( my_io ).to receive( :puts ).with 'my string'
+
+            colorized_logger.optionally_color "\e[01;30m", 'my string'
+          end
+
+        end
+
+        context 'color host output' do
+          subject( :color_host_output ) { Logger.new( my_io,
+                                              :log_level => :verbose,
+                                              :quiet     => true,
+                                              :color     => true )}
+
+          it 'colors host_output' do
+            colorized_logger = color_host_output
+
+            expect( my_io ).to receive( :print ).with ""
+            expect( my_io ).to receive( :puts ).with 'my string'
+
+            colorized_logger.optionally_color "", 'my string'
+          end
+
+        end
+      end
+
     end
   end
 end

data/spec/beaker/options/command_line_parser_spec.rb

@@ -6,8 +6,8 @@ module Beaker
 
       let(:parser) {Beaker::Options::CommandLineParser.new}
       let(:test_opts) {["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"]}
-      let(:full_opts_in)  {["--hosts", "host.cfg",           "--options", "opts_file", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--no-provision", "--preserve-hosts", "always",   "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath",     "-m", "module",         "-q",    "--dry-run",       "--no-ntp",    "--repo-proxy",    "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast",  "--no-color",    "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128",    "--collect-perf-data",    "--parse-only",    "--validate", "--timeout", "40", "--log-prefix", "pants",      "--configure",         "--tag", "1,2,3", "--exclude-tag", "4,5,6",        "--xml-time-order"]}
-      let(:full_opts_out) {{:hosts_file=>"anotherfile.cfg",:options_file=>"opts_file",  :helper => "path_to_helper",  :load_path => "load_path",  :tests => "test1.rb,test2.rb,test3.rb",  :pre_suite => "pre_suite.rb",  :post_suite => "post_suite.rb", :provision=>false, :preserve_hosts => "always", :root_keys=>true, :keyfile => "../.ssh/id_rsa",  :install => "gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true,                                 :fail_mode => "fast", :color=>false, :beaker_version_print=>true,  :log_level => "info",  :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>true, :parse_only=>true, :validate=>true,  :timeout => "40",  :log_prefix => "pants", :configure => true, :tag_includes => "1,2,3", :tag_excludes => "4,5,6", :xml_time_enabled => true}}
+      let(:full_opts_in)  {["--hosts", "host.cfg",           "--options", "opts_file", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--no-provision", "--preserve-hosts", "always",   "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath",     "-m", "module",         "-q",    "--dry-run",       "--no-ntp",    "--repo-proxy",    "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast",  "--no-color", "--no-color-host-output",  "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128",    "--collect-perf-data",    "--parse-only",    "--validate", "--timeout", "40", "--log-prefix", "pants",      "--configure",         "--tag", "1,2,3", "--exclude-tag", "4,5,6",        "--xml-time-order"]}
+      let(:full_opts_out) {{:hosts_file=>"anotherfile.cfg",:options_file=>"opts_file",  :helper => "path_to_helper",  :load_path => "load_path",  :tests => "test1.rb,test2.rb,test3.rb",  :pre_suite => "pre_suite.rb",  :post_suite => "post_suite.rb", :provision=>false, :preserve_hosts => "always", :root_keys=>true, :keyfile => "../.ssh/id_rsa",  :install => "gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true,                                 :fail_mode => "fast", :color=>false, :color_host_output=>false, :beaker_version_print=>true,  :log_level => "info",  :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>true, :parse_only=>true, :validate=>true,  :timeout => "40",  :log_prefix => "pants", :configure => true, :tag_includes => "1,2,3", :tag_excludes => "4,5,6", :xml_time_enabled => true}}
       let(:validate_true)  {["--validate"]}
       let(:validate_false) {["--no-validate"]}
       let(:configure_true)  {['--configure']}

data/spec/beaker/options/options_hash_spec.rb

@@ -5,16 +5,6 @@ module Beaker
     describe OptionsHash do
       let(:options)    { Beaker::Options::OptionsHash.new }
 
-      #test options hash methods
-      it "converts all string keys to symbols when doing direct assignment" do
-        options['key'] = 'value'
-        expect(options.has_key?(:key)) === true  and expect(options.has_key?('key')) === false
-      end
-
-      it "can look up by string or symbol key" do
-        options.merge({'key' => 'value'})
-        expect(options['key']) === 'value' and expect(options[:key]) === 'value'
-      end
 
       it "supports is_pe?, defaults to pe" do
         expect(options.is_pe?).to be_truthy
@@ -25,26 +15,6 @@ module Beaker
         expect(options.is_pe?).to be_falsy
       end
 
-      it "can delete by string of symbol key" do
-        options['key'] = 'value'
-        expect(options.delete('key')) === 'value' and expect(options.delete(:key)) === 'value'
-      end
-
-      it "when merged with a Hash remains an OptionsHash" do
-        options.merge({'key' => 'value'})
-        expect(options.is_a?(OptionsHash)) === true
-      end
-
-      it "when merged with a hash that contains a hash, the sub-hash becomes an OptionsHash" do
-        newhash = options.merge({'key' => {'subkey' => 'subvalue'}})
-        expect(newhash[:key].is_a?(OptionsHash)) === true and expect(newhash[:key][:subkey]) === 'subvalue'
-      end
-
-      it "does not alter the original hash when doing a merge" do
-        options.merge({'key' => {'subkey' => 'subvalue'}})
-        expect(options[:key]).to be === nil
-      end
-
       describe '#get_type' do
         let(:options) { Beaker::Options::OptionsHash.new }
 
@@ -58,83 +28,12 @@ module Beaker
           expect(newhash.get_type).to be === :foss
         end
 
-        it 'returns aio as expected in the normal case' do
-          newhash = options.merge({:type => 'aio'})
-          expect(newhash.get_type).to be === :aio
-        end
-
         it 'returns foss as the default' do
           newhash = options.merge({:type => 'git'})
           expect(newhash.get_type).to be === :foss
         end
       end
-
-      context 'pretty prints itself' do
-
-        it 'in valid JSON' do
-          require 'json'
-
-          options['array'] = ['one', 'two', 'three']
-          options['hash'] = {'subkey' => { 'subsub' => 1 }}
-          options['nil'] = nil
-          options['number'] = 4
-          options['float'] = 1.0
-          options['string'] = 'string'
-          options['true'] = true
-
-          expect{ JSON.parse( options.dump ) }.to_not raise_error
-        end
-
-        context 'for non collection values shows' do
-          it 'non-string like values as bare words' do
-            expect( options.fmt_value( 4 ) ).to be == "4"
-            expect( options.fmt_value( 1.0 ) ).to be == "1.0"
-            expect( options.fmt_value( true ) ).to be == "true"
-            expect( options.fmt_value( false ) ).to be == "false"
-          end
-
-          it 'nil values as null' do
-            expect( options.fmt_value( nil ) ).to be == 'null'
-          end
-
-          it 'strings within double quotes' do
-            expect( options.fmt_value( 'thing' ) ).to be == '"thing"'
-          end
-        end
-
-        context 'for list like collections shows' do
-          it 'each element on a new line' do
-            fmt_list = options.fmt_value( %w{ one two three } )
-
-            expect( fmt_list ).to match(/^\s*"one",?$/)
-            expect( fmt_list ).to match(/^\s*"two",?$/)
-            expect( fmt_list ).to match(/^\s*"three",?$/)
-          end
-
-          it 'square brackets on either end of the list' do
-            fmt_list = options.fmt_value( %w{ one two three } )
-
-            expect( fmt_list ).to match( /\A\[\s*$/ )
-            expect( fmt_list ).to match( /^\s*\]\Z/ )
-          end
-        end
-
-        context 'for dict like collections shows' do
-          it 'each element on a new line' do
-            fmt_assoc = options.fmt_value( {:one => 'two', :two => 'three'} )
-
-            expect( fmt_assoc ).to match(/^\s*"one": "two",?$/)
-            expect( fmt_assoc ).to match(/^\s*"two": "three",?$/)
-          end
-
-          it 'curly braces on either end of the list' do
-            fmt_assoc = options.fmt_value( {:one => 'two', :two => 'three'} )
-
-            expect( fmt_assoc ).to match( /\A\{\s*$/ )
-            expect( fmt_assoc ).to match( /^\s*\}\Z/ )
-          end
-        end
-      end
     end
+
   end
 end

data/spec/beaker/options/parser_spec.rb

@@ -402,6 +402,25 @@ module Beaker
           expect( options[:tag_excludes] ).to be === ['leet_speak', 'poland']
         end
       end
+
+      describe '#resolve_symlinks' do
+        let ( :options )  { Beaker::Options::OptionsHash.new }
+
+        it 'calls File.realpath if hosts_file is set' do
+          options[:hosts_file] = opts_path
+          parser.instance_variable_set(:@options, options)
+
+          parser.resolve_symlinks()
+          expect( parser.instance_variable_get(:@options)[:hosts_file] ).to be === opts_path
+        end
+
+        it 'does not throw an error if hosts_file is not set' do
+          options[:hosts_file] = nil
+          parser.instance_variable_set(:@options, options)
+
+          expect{ parser.resolve_symlinks() }.to_not raise_error
+        end
+      end
     end
   end
 end

data/spec/beaker/options/pe_version_scaper_spec.rb

@@ -8,9 +8,19 @@ module Beaker
         latest = File.open(filename, 'w')
         latest.write('3.7.1-rc0-8-g73f93cb')
         latest.close
-        expect(PEVersionScraper.load_pe_version('.', filename)) === '3.0.0'
+        expect(PEVersionScraper.load_pe_version('.', filename)).to be === "3.7.1-rc0-8-g73f93cb"
         File.delete(filename)
       end
+
+      it "can pull version from preview LATEST file" do
+        filename = 'LATEST'
+        latest = File.open(filename, 'w')
+        latest.write('3.8.1')
+        latest.close
+        expect(PEVersionScraper.load_pe_version('.', filename)).to be === '3.8.1'
+        File.delete(filename)
+      end
+
       it "raises error when file doesn't exist" do
         expect{PEVersionScraper.load_pe_version("not a valid path", "not a valid filename")}.to raise_error(ArgumentError)
       end

data/spec/beaker/options/presets_spec.rb

@@ -10,6 +10,14 @@ module Beaker
         expect(presets.env_vars).to be_instance_of(Beaker::Options::OptionsHash)
       end
 
+      it "pulls in env vars of the form ':q_*' and adds them to the :answers of the OptionsHash" do
+         ENV['q_puppet_cloud_install'] = 'n'
+         env = presets.env_vars
+         expect(env[:answers][:q_puppet_cloud_install]).to be === 'n'
+         expect(env[:answers]['q_puppet_cloud_install']).to be === 'n'
+         ENV.delete('q_puppet_cloud_install')
+      end
+
       it "removes all empty/nil entries in env_vars" do
         expect(presets.env_vars.has_value?(nil)).to be === false
         expect(presets.env_vars.has_value?({})).to be === false

data/spec/beaker/ssh_connection_spec.rb

@@ -3,11 +3,14 @@ require 'net/ssh'
 
 module Beaker
   describe SshConnection do
-    let( :host )     { 'my_host' }
-    let( :user )     { 'root'    }
-    let( :ssh_opts ) { {} }
-    let( :options )  { { :logger => double('logger').as_null_object }  }
-    subject(:connection) { SshConnection.new host, user, ssh_opts, options }
+    let( :user )      { 'root'    }
+    let( :ssh_opts )  { {} }
+    let( :options )   { { :logger => double('logger').as_null_object }  }
+    let( :ip )        { "default.ip.address" }
+    let( :vmhostname ){ "vmhostname" }
+    let( :hostname)   { "my_host" }
+    let( :name_hash ) { { :ip => ip, :vmhostname => vmhostname, :hostname => hostname } }
+    subject(:connection) { SshConnection.new name_hash, user, ssh_opts, options }
 
     before :each do
       allow( subject ).to receive(:sleep)
@@ -15,27 +18,42 @@ module Beaker
 
     it 'self.connect creates connects and returns a proxy for that connection' do
       # grrr
-      expect( Net::SSH ).to receive(:start).with( host, user, ssh_opts )
-      connection_constructor = SshConnection.connect host, user, ssh_opts, options
+      expect( Net::SSH ).to receive(:start).with( ip, user, ssh_opts ).and_return(true)
+      connection_constructor = SshConnection.connect name_hash, user, ssh_opts, options
       expect( connection_constructor ).to be_a_kind_of SshConnection
     end
 
     it 'connect creates a new connection' do
-      expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts)
+      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts).and_return(true)
       connection.connect
     end
 
     it 'connect caches its connection' do
-      expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts ).once.and_return true
+      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts ).once.and_return true
       connection.connect
       connection.connect
     end
 
+    it 'attempts to connect by vmhostname if ip address connection fails' do
+      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts).and_return(false)
+      expect( Net::SSH ).to receive( :start ).with( vmhostname, user, ssh_opts).and_return(true).once
+      expect( Net::SSH ).to receive( :start ).with( hostname, user, ssh_opts).never
+      connection.connect
+    end
+
+    it 'attempts to connect by hostname, if vmhost + ipaddress have failed' do
+      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts).and_return(false)
+      expect( Net::SSH ).to receive( :start ).with( vmhostname, user, ssh_opts).and_return(false)
+      expect( Net::SSH ).to receive( :start ).with( hostname, user, ssh_opts).and_return(true).once
+      connection.connect
+
+    end
+
     describe '#close' do
 
       it 'runs ssh close' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         allow( mock_ssh).to receive( :closed? ).once.and_return(false)
@@ -45,7 +63,7 @@ module Beaker
 
       it 'sets the @ssh variable to nil' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         allow( mock_ssh).to receive( :closed? ).once.and_return(false)
@@ -58,7 +76,7 @@ module Beaker
       it 'calls ssh shutdown & re-raises if ssh close fails with an unexpected Error' do
         mock_ssh = Object.new
         allow( mock_ssh ).to receive( :close ) { raise StandardError }
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         allow( mock_ssh).to receive( :closed? ).once.and_return(false)
@@ -72,7 +90,7 @@ module Beaker
     describe '#execute' do
       it 'retries if failed with a retryable exception' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         allow( subject ).to receive( :close )
@@ -84,20 +102,20 @@ module Beaker
 
       it 'raises an error if it fails both times' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         allow( subject ).to receive( :close )
         allow( subject ).to receive( :try_to_execute ) { raise Timeout::Error }
 
-        expect{ connection.execute('ls') }.to raise_error
+        expect{ connection.execute('ls') }.to raise_error Timeout::Error
       end
     end
 
     describe '#request_terminal_for' do
       it 'fails correctly by calling the abort method' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         mock_channel = Object.new
@@ -111,7 +129,7 @@ module Beaker
     describe '#register_stdout_for' do
       before :each do
         @mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { @mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
 
         @data = '7 of clubs'
@@ -147,7 +165,7 @@ module Beaker
 
       before :each do
         @mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { @mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
 
         @data = '3 of spades'
@@ -186,7 +204,7 @@ module Beaker
 
       it 'assigns the output\'s exit code correctly from the data' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         data = '10 of jeromes'
@@ -219,7 +237,7 @@ module Beaker
         @mock_scp = Object.new
         allow( @mock_scp ).to receive( :upload! )
         allow( @mock_ssh ).to receive( :scp ).and_return( @mock_scp )
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { @mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
       end
 
@@ -240,7 +258,7 @@ module Beaker
         @mock_scp = Object.new
         allow( @mock_scp ).to receive( :download! )
         allow( @mock_ssh ).to receive( :scp ).and_return( @mock_scp )
-        expect( Net::SSH ).to receive( :start ).with( host, user, ssh_opts) { @mock_ssh }
+        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
       end
 

data/spec/helpers.rb

@@ -7,8 +7,8 @@ module TestFileHelpers
   end
 
   def fog_file_contents
-    { :default => { :aws_access_key_id => "IMANACCESSKEY",
-                    :aws_secret_access_key => "supersekritkey",
+    { :default => { :access_key => "IMANACCESSKEY",
+                    :secret_access => "supersekritkey",
                     :aix_hypervisor_server => "aix_hypervisor.labs.net",
                     :aix_hypervisor_username => "aixer",
                     :aix_hypervisor_keyfile => "/Users/user/.ssh/id_rsa-acceptance",
@@ -27,10 +27,11 @@ end
 module HostHelpers
   HOST_DEFAULTS = { :platform => 'unix',
                     :snapshot => 'pe',
-                    :box => 'box_name',
                     :roles => ['agent'],
                     :snapshot => 'snap',
                     :ip => 'default.ip.address',
+                    :private_ip => 'private.ip.address',
+                    :dns_name => 'default.box.tld',
                     :box => 'default_box_name',
                     :box_url => 'http://default.box.url',
   }
@@ -40,7 +41,9 @@ module HostHelpers
   HOST_IP       = "ip.address.for.%s"
   HOST_BOX      = "%s_of_my_box"
   HOST_BOX_URL  = "http://address.for.my.box.%s"
+  HOST_DNS_NAME = "%s.box.tld"
   HOST_TEMPLATE = "%s_has_a_template"
+  HOST_PRIVATE_IP = "private.ip.for.%s"
 
   def logger
     double( 'logger' ).as_null_object
@@ -83,6 +86,7 @@ module HostHelpers
     host = Beaker::Host.create( name, host_hash, make_opts)
 
     allow(host).to receive( :exec ).and_return( generate_result( name, host_hash ) )
+    allow(host).to receive( :close )
     host
   end
 
@@ -92,6 +96,8 @@ module HostHelpers
       name = HOST_NAME % num
       opts = { :snapshot => HOST_SNAPSHOT % num,
                :ip => HOST_IP % name,
+               :private_ip => HOST_PRIVATE_IP % name,
+               :dns_name => HOST_DNS_NAME % name,
                :template => HOST_TEMPLATE % name,
                :box => HOST_BOX % name,
                :box_url => HOST_BOX_URL % name }.merge( preset_opts )