beaker 2.7.1 → 2.8.0

data/lib/beaker/options/command_line_parser.rb

@@ -137,6 +137,13 @@ module Beaker
             @cmd_options[:log_level] = val
           end
 
+          opts.on '--log-prefix PREFIX',
+                  'Use a custom prefix for your Beaker log files',
+                  'can provide nested directories (ie. face/man)',
+                  '(defaults to hostfile name. ie. ../i/07.yml --> "07")' do |val|
+            @cmd_options[:log_prefix] = val
+          end
+
           opts.on  '-d', '--[no-]dry-run',
                    'Report what would happen on targets',
                    '(default: false)' do |bool|

data/lib/beaker/shared.rb

@@ -1,4 +1,4 @@
-[ 'repetition', 'error_handler', 'host_manager', 'timed' ].each do |lib|
+[ 'repetition', 'error_handler', 'host_manager', 'timed', 'semvar' ].each do |lib|
   require "beaker/shared/#{lib}"
 end
 module Beaker
@@ -7,6 +7,7 @@ module Beaker
     include Beaker::Shared::HostManager
     include Beaker::Shared::Repetition
     include Beaker::Shared::Timed
+    include Beaker::Shared::Semvar
   end
 end
 include Beaker::Shared

data/lib/beaker/shared/semvar.rb

@@ -0,0 +1,41 @@
+module Beaker
+  module Shared
+    module Semvar
+
+      #Is semver-ish version a less than semver-ish version b
+      #@param [String] a A version of the from '\d.\d.\d.*'
+      #@param [String] b A version of the form '\d.\d.\d.*'
+      #@return [Boolean] true if a is less than b, otherwise return false
+      #
+      #@note 3.0.0-160-gac44cfb is greater than 3.0.0, and 2.8.2
+      #@note -rc being less than final builds is not yet implemented.
+      def version_is_less a, b
+        a_nums = a.split('-')[0].split('.')
+        b_nums = b.split('-')[0].split('.')
+        (0...a_nums.length).each do |i|
+          if i < b_nums.length
+            if a_nums[i] < b_nums[i]
+              return true
+            elsif a_nums[i] > b_nums[i]
+              return false
+            end
+          else
+            return false
+          end
+        end
+        #checks all dots, they are equal so examine the rest
+        a_rest = a.split('-', 2)[1]
+        b_rest = b.split('-', 2)[1]
+        if a_rest and b_rest and a_rest < b_rest
+          return false
+        elsif a_rest and not b_rest
+          return false
+        elsif not a_rest and b_rest
+          return true
+        end
+        return false
+      end
+    end
+  end
+end
+

data/lib/beaker/test_suite.rb

@@ -336,7 +336,7 @@ module Beaker
     # Gives a full file path for output to be written to, maintaining the latest symlink
     # @param [String] name The file name that we want to write to.
     # @param [String] log_dir The desired output directory.
-    #                         A symlink will be made from ./parentdir/latest to that.
+    #                         A symlink will be made from ./basedir/latest to that.
     # @example
     #   log_path('output.txt', 'log/2014-06-02_16_31_22')
     #
@@ -344,17 +344,31 @@ module Beaker
     #
     #   ./log/2014-06-02_16_31_22/output.txt
     #   ./log/latest -> 2014-06-02_16_31_22
+    #
+    # @example
+    #   log_path('foo.log', 'log/man/date')
+    #
+    #     This will create the structure:
+    #
+    #   ./log/man/date/foo.log
+    #   ./log/latest -> man/date
     def log_path(name, log_dir)
-      log_parent_dir = File.dirname(log_dir)
       FileUtils.mkdir_p(log_dir) unless File.directory?(log_dir)
 
-      latest = File.join(log_parent_dir, "latest")
+      base_dir = log_dir
+      link_dir = ''
+      while File.dirname(base_dir) != '.' do
+        link_dir = link_dir == '' ? File.basename(base_dir) : File.join(File.basename(base_dir), link_dir)
+        base_dir = File.dirname(base_dir)
+      end
+
+      latest = File.join(base_dir, "latest")
       if !File.exist?(latest) or File.symlink?(latest) then
-        File.delete(latest) if File.exist?(latest)
-        File.symlink(File.basename(log_dir), latest)
+        File.delete(latest) if File.exist?(latest) || File.symlink?(latest)
+        File.symlink(link_dir, latest)
       end
 
-      File.join(log_parent_dir, 'latest', name)
+      File.join(log_dir, name)
     end
 
   end

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '2.7.1'
+    STRING = '2.8.0'
   end
 end

data/spec/beaker/dsl/helpers/facter_helpers_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLHelpers
+  include Beaker::DSL::Helpers
+  include Beaker::DSL::Wrappers
+  include Beaker::DSL::Roles
+  include Beaker::DSL::Patterns
+
+  def logger
+    RSpec::Mocks::Double.new('logger').as_null_object
+  end
+
+end
+
+describe ClassMixedWithDSLHelpers do
+  let( :command ){ 'ls' }
+  let( :host )   { double.as_null_object }
+  let( :result ) { Beaker::Result.new( host, command ) }
+
+  let( :master ) { make_host( 'master',   :roles => %w( master agent default)    ) }
+  let( :agent )  { make_host( 'agent',    :roles => %w( agent )           ) }
+  let( :custom ) { make_host( 'custom',   :roles => %w( custom agent )    ) }
+  let( :dash )   { make_host( 'console',  :roles => %w( dashboard agent ) ) }
+  let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
+  let( :hosts )  { [ master, agent, dash, db, custom ] }
+
+
+  describe '#fact_on' do
+    it 'retrieves a fact on a single host' do
+      result.stdout = "family\n"
+      expect( subject ).to receive(:facter).with('osfamily',{}).once
+      expect( subject ).to receive(:on).and_return(result)
+
+      expect( subject.fact_on('host','osfamily') ).to be === result.stdout.chomp
+    end
+
+    it 'retrieves an array of facts from multiple hosts' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      times = hosts.length
+      result.stdout = "family\n"
+      hosts.each do |host|
+        expect( host ).to receive(:exec).and_return(result)
+      end
+
+      expect( subject.fact_on(hosts,'osfamily') ).to be === [result.stdout.chomp] * hosts.length
+
+    end
+  end
+
+  describe '#fact' do
+    it 'delegates to #fact_on with the default host' do
+      allow( subject ).to receive(:hosts).and_return(hosts)
+      expect( subject ).to receive(:fact_on).with(master,"osfamily",{}).once
+
+      subject.fact('osfamily')
+    end
+  end
+
+end

data/spec/beaker/dsl/helpers/hiera_helpers_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLHelpers
+  include Beaker::DSL::Helpers
+  include Beaker::DSL::Wrappers
+  include Beaker::DSL::Roles
+  include Beaker::DSL::Patterns
+
+  def logger
+    RSpec::Mocks::Double.new('logger').as_null_object
+  end
+
+end
+
+describe ClassMixedWithDSLHelpers do
+  let( :opts )   { Beaker::Options::Presets.env_vars }
+  let( :command ){ 'ls' }
+  let( :host )   { double.as_null_object }
+  let( :result ) { Beaker::Result.new( host, command ) }
+
+  let( :master ) { make_host( 'master',   :roles => %w( master agent default)    ) }
+  let( :agent )  { make_host( 'agent',    :roles => %w( agent )           ) }
+  let( :custom ) { make_host( 'custom',   :roles => %w( custom agent )    ) }
+  let( :dash )   { make_host( 'console',  :roles => %w( dashboard agent ) ) }
+  let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
+  let( :hosts )  { [ master, agent, dash, db, custom ] }
+
+
+  describe "#write_hiera_config_on" do
+    let(:hierarchy) { [ 'nodes/%{::fqdn}', 'common' ] }
+    it 'on FOSS host' do
+      host = make_host('testhost', { :platform => 'ubuntu' } )
+      expect(subject).to receive(:create_remote_file).with(host, host.puppet['hiera_config'], /#{host[:hieradatadir]}/)
+      subject.write_hiera_config_on(host, hierarchy)
+    end
+
+    it 'on PE host' do
+      host = make_host('testhost', { :platform => 'ubuntu', :type => 'pe' } )
+      expect(subject).to receive(:create_remote_file).with(host, host.puppet['hiera_config'], /#{host[:hieradatadir]}/)
+      subject.write_hiera_config_on(host, hierarchy)
+    end
+
+  end
+
+  describe "#write_hiera_config" do
+    let(:hierarchy) { [ 'nodes/%{::fqdn}', 'common' ] }
+    it 'delegates to #write_hiera_config_on with the default host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :write_hiera_config_on ).with( master, hierarchy).once
+      subject.write_hiera_config( hierarchy )
+    end
+
+  end
+
+  describe "#copy_hiera_data_to" do
+    let(:path) { 'spec/fixtures/hieradata' }
+    it 'on FOSS host' do
+      host = make_host('testhost', { :platform => 'ubuntu' } )
+      expect(subject).to receive(:scp_to).with(host, File.expand_path(path), host[:hieradatadir])
+      subject.copy_hiera_data_to(host, path)
+    end
+
+    it 'on PE host' do
+      host = make_host('testhost', { :platform => 'ubuntu', :type => 'pe' } )
+      expect(subject).to receive(:scp_to).with(host, File.expand_path(path), host[:hieradatadir])
+      subject.copy_hiera_data_to(host, path)
+    end
+  end
+
+  describe "#copy_hiera_data" do
+    let(:path) { 'spec/fixtures/hieradata' }
+    it 'delegates to #copy_hiera_data_to with the default host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :copy_hiera_data_to ).with( master, path).once
+      subject.copy_hiera_data( path )
+    end
+
+  end
+
+  describe '#hiera_datadir' do
+    it 'returns the codedir based hieradatadir for AIO' do
+      host = hosts[0]
+      host['type'] = :aio
+      correct_answer = File.join(host.puppet['codedir'], 'hieradata')
+      expect( subject.hiera_datadir(host) ).to be === correct_answer
+    end
+
+    it 'returns the hieradata host value for anything not AIO (backwards compatible)' do
+      host_hieradatadir_value = '/home/fishing/man/pants'
+      host = hosts[0]
+      host[:hieradatadir] = host_hieradatadir_value
+      expect( subject.hiera_datadir(host) ).to be === host_hieradatadir_value
+    end
+  end
+
+end

data/spec/beaker/dsl/helpers/host_helpers_spec.rb

@@ -0,0 +1,413 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLHelpers
+  include Beaker::DSL::Helpers
+  include Beaker::DSL::Wrappers
+  include Beaker::DSL::Roles
+  include Beaker::DSL::Patterns
+
+  def logger
+    RSpec::Mocks::Double.new('logger').as_null_object
+  end
+
+end
+
+describe ClassMixedWithDSLHelpers do
+  let( :opts )   { Beaker::Options::Presets.env_vars }
+  let( :command ){ 'ls' }
+  let( :host )   { double.as_null_object }
+  let( :result ) { Beaker::Result.new( host, command ) }
+
+  let( :master ) { make_host( 'master',   :roles => %w( master agent default)    ) }
+  let( :agent )  { make_host( 'agent',    :roles => %w( agent )           ) }
+  let( :custom ) { make_host( 'custom',   :roles => %w( custom agent )    ) }
+  let( :dash )   { make_host( 'console',  :roles => %w( dashboard agent ) ) }
+  let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
+  let( :hosts )  { [ master, agent, dash, db, custom ] }
+
+  describe '#on' do
+
+    before :each do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+      result.exit_code = 0
+    end
+
+    it 'allows the environment the command is run within to be specified' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      expect( Beaker::Command ).to receive( :new ).
+        with( 'ls ~/.bin', [], {'ENV' => { :HOME => '/tmp/test_home' }} )
+
+      subject.on( host, 'ls ~/.bin', :environment => {:HOME => '/tmp/test_home' } )
+    end
+
+    it 'if the host is a String Object, finds the matching hosts with that String as role' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      expect( master ).to receive( :exec ).once
+
+      subject.on( 'master', 'echo hello')
+
+    end
+
+    it 'if the host is a Symbol Object, finds the matching hsots with that Symbol as role' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      expect( master ).to receive( :exec ).once
+
+      subject.on( :master, 'echo hello')
+
+    end
+
+    it 'delegates to itself for each host passed' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expected = []
+      hosts.each_with_index do |host, i|
+        expected << i
+        expect( host ).to receive( :exec ).and_return( i )
+      end
+
+      results = subject.on( hosts, command )
+      expect( results ).to be == expected
+    end
+
+    context 'upon command completion' do
+      before :each do
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
+        @res = subject.on( host, command )
+      end
+
+      it 'returns the result of the action' do
+        expect( @res ).to be == result
+      end
+
+      it 'provides access to stdout' do
+        expect( @res.stdout ).to be == 'stdout'
+      end
+
+      it 'provides access to stderr' do
+        expect( @res.stderr ).to be == 'stderr'
+      end
+
+      it 'provides access to exit_code' do
+        expect( @res.exit_code ).to be == 0
+      end
+    end
+
+    context 'when passed a block with arity of 1' do
+      before :each do
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
+      end
+
+      it 'yields result' do
+        subject.on host, command do |containing_class|
+          expect( containing_class ).
+            to be_an_instance_of( Beaker::Result )
+        end
+      end
+
+      it 'provides access to stdout' do
+        subject.on host, command do |containing_class|
+          expect( containing_class.stdout ).to be == 'stdout'
+        end
+      end
+
+      it 'provides access to stderr' do
+        subject.on host, command do |containing_class|
+          expect( containing_class.stderr ).to be == 'stderr'
+        end
+      end
+
+      it 'provides access to exit_code' do
+        subject.on host, command do |containing_class|
+          expect( containing_class.exit_code ).to be == 0
+        end
+      end
+    end
+
+    context 'when passed a block with arity of 0' do
+      before :each do
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
+      end
+
+      it 'yields self' do
+        subject.on host, command do
+          expect( subject ).
+            to be_an_instance_of( ClassMixedWithDSLHelpers )
+        end
+      end
+
+      it 'provides access to stdout' do
+        subject.on host, command do
+          expect( subject.stdout ).to be == 'stdout'
+        end
+      end
+
+      it 'provides access to stderr' do
+        subject.on host, command do
+          expect( subject.stderr ).to be == 'stderr'
+        end
+      end
+
+      it 'provides access to exit_code' do
+        subject.on host, command do
+          expect( subject.exit_code ).to be == 0
+        end
+      end
+    end
+
+  end
+
+  describe "#retry_on" do
+    it 'fails correctly when command never succeeds' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+      result.exit_code = 1
+
+      retries = 5
+
+      opts = {
+        :max_retries    => retries,
+        :retry_interval => 0.0001,
+      }
+
+      allow( subject ).to receive(:on).and_return(result)
+      expect( subject ).to receive(:on).exactly(retries+2)
+      expect { subject.retry_on(host, command, opts) }.to raise_error(RuntimeError)
+    end
+
+    it 'will return success correctly if it succeeds the first time' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+      result.exit_code = 0
+
+      opts = {
+        :max_retries    => 5,
+        :retry_interval => 0.0001,
+      }
+
+      allow( subject ).to receive(:on).and_return(result)
+      expect( subject ).to receive(:on).once
+
+      result_given = subject.retry_on(host, command, opts)
+      expect(result_given.exit_code).to be === 0
+    end
+
+    it 'will return success correctly if it succeeds after failing a few times' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+
+      opts = {
+        :max_retries    => 10,
+        :retry_interval => 0.1,
+      }
+
+      reps_num = 4
+      count = 0
+      allow( subject ).to receive(:on) do
+        result.exit_code = count > reps_num ? 0 : 1
+        count += 1
+        result
+      end
+      expect( subject ).to receive(:on).exactly(reps_num + 2)
+
+      result_given = subject.retry_on(host, command, opts)
+      expect(result_given.exit_code).to be === 0
+    end
+  end
+
+  describe "shell" do
+    it 'delegates to #on with the default host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      expect( subject ).to receive( :on ).with( master, "echo hello", {}).once
+
+      subject.shell( "echo hello" )
+    end
+  end
+
+  describe '#scp_from' do
+    it 'delegates to the host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
+      expect( result ).to receive( :log ).exactly( hosts.length ).times
+
+      hosts.each do |host|
+        expect( host ).to receive( :do_scp_from ).and_return( result )
+      end
+
+      subject.scp_from( hosts, '/var/log/my.log', 'log/my.log' )
+    end
+  end
+
+  describe '#scp_to' do
+    it 'delegates to the host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
+      expect( result ).to receive( :log ).exactly( hosts.length ).times
+
+      hosts.each do |host|
+        expect( host ).to receive( :do_scp_to ).and_return( result )
+      end
+
+      subject.scp_to( hosts, '/var/log/my.log', 'log/my.log' )
+    end
+  end
+
+  describe '#rsync_to' do
+    it 'delegates to the host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      hosts.each do |host|
+        expect( host ).to receive( :do_rsync_to ).and_return( result )
+      end
+
+      subject.rsync_to( hosts, '/var/log/my.log', 'log/my.log' )
+    end
+  end
+
+  describe '#create_remote_file using scp' do
+    it 'scps the contents passed in to the hosts' do
+      my_opts = { :silent => true }
+      tmpfile = double
+
+      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
+        and_return( '/local/path/to/blah' )
+
+      expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
+
+      expect( File ).to receive( :open )
+
+      expect( subject ).to receive( :scp_to ).
+        with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
+
+      subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
+    end
+  end
+
+  describe '#create_remote_file using rsync' do
+    it 'scps the contents passed in to the hosts' do
+      my_opts = { :silent => true, :protocol => 'rsync' }
+      tmpfile = double
+
+      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
+        and_return( '/local/path/to/blah' )
+
+      expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
+
+      expect( File ).to receive( :open )
+
+      expect( subject ).to receive( :rsync_to ).
+        with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
+
+      subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
+    end
+  end
+
+  describe '#create_tmpdir_on' do
+    let(:host) { {'user' => 'puppet'} }
+    let(:result) { double.as_null_object }
+
+    before :each do
+      allow(host).to receive(:result).and_return(result)
+      allow(result).to receive(:exit_code).and_return(0)
+      allow(result).to receive(:stdout).and_return('puppet')
+    end
+
+    context 'with no user argument' do
+
+      context 'with no path name argument' do
+        it 'executes chown once' do
+          expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
+          expect(host).to receive(:tmpdir).with(/\/tmp\/beaker.*/)
+          expect(subject).to receive(:on).with(host, /chown puppet.puppet.*/)
+          subject.create_tmpdir_on(host, '/tmp/beaker')
+        end
+      end
+
+      context 'with path name argument' do
+        it 'executes chown once' do
+          expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
+          expect(host).to receive(:tmpdir).with(/\/tmp\/bogus.*/).and_return("/tmp/bogus")
+          expect(subject).to receive(:on).with(host, /chown puppet.puppet \/tmp\/bogus.*/)
+          subject.create_tmpdir_on(host, "/tmp/bogus")
+        end
+      end
+
+    end
+
+    context 'with an valid user argument' do
+      it 'executes chown once' do
+        expect(subject).to receive(:on).with(host, /^getent passwd curiousgeorge/).and_return(result)
+        expect(host).to receive(:tmpdir).with(/\/tmp\/bogus.*/).and_return("/tmp/bogus")
+        expect(subject).to receive(:on).with(host, /chown curiousgeorge.curiousgeorge \/tmp\/bogus.*/)
+        subject.create_tmpdir_on(host, "/tmp/bogus", "curiousgeorge")
+      end
+    end
+
+    context 'with a invalid user argument' do
+      it 'executes chown once' do
+        allow(result).to receive(:exit_code).and_return(1)
+        expect(subject).to receive(:on).with(host, /^getent passwd curiousgeorge/).and_return(result)
+        expect{
+          subject.create_tmpdir_on(host, "/tmp/bogus", "curiousgeorge")
+        }.to raise_error(RuntimeError, /User curiousgeorge does not exist on/)
+      end
+    end
+
+  end
+
+  describe '#run_script_on' do
+    it 'scps the script to a tmpdir and executes it on host(s)' do
+      expect( subject ).to receive( :scp_to )
+      expect( subject ).to receive( :on )
+      subject.run_script_on( 'host', '~/.bin/make-enterprisy' )
+    end
+  end
+
+  describe '#run_script' do
+    it 'delegates to #run_script_on with the default host' do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+
+      expect( subject ).to receive( :run_script_on ).with( master, "/tmp/test.sh", {}).once
+
+      subject.run_script( '/tmp/test.sh' )
+    end
+  end
+
+  describe '#add_system32_hosts_entry' do
+    before do
+      allow( subject ).to receive(:on).and_return(Beaker::Result.new({},''))
+    end
+    context 'on debian' do
+      let(:platform) { 'debian-7-amd64' }
+      let(:host) { make_host('testbox.test.local', :platform => 'debian-7-amd64') }
+      it 'logs message - nothing to do on this host' do
+        expect( Beaker::Command ).to receive( :new ).never
+
+        expect {
+          subject.add_system32_hosts_entry(host, {})
+        }.to raise_error
+      end
+    end
+    context 'on windows' do
+      let(:platform) { 'windows-2008R2-amd64' }
+      let(:host) { make_host('testbox.test.local', :platform => 'windows-2008R2-amd64') }
+      it 'it add an entry into the /etc/hosts file' do
+        entry = { 'ip' => '23.251.154.122', 'name' => 'forge.puppetlabs.com' }
+        expect(subject).to receive(:on) do |host, command|
+          expect(command.command).to eq('powershell.exe')
+          expect(command.args).to eq(["-ExecutionPolicy Bypass", "-InputFormat None", "-NoLogo", "-NoProfile", "-NonInteractive", "-Command $text = \\\"23.251.154.122`t`tforge.puppetlabs.com\\\"; Add-Content -path 'C:\\Windows\\System32\\Drivers\\etc\\hosts' -value $text"])
+        end
+
+
+        subject.add_system32_hosts_entry(host, entry)
+      end
+    end
+  end
+
+end