vagrant-windows-domain 1.1.9 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cec07d512096a25b4795721fc93e328fe27d5cd
-  data.tar.gz: 78e9f4ee8d880ad7c92125329f0e7cff36006d52
+  metadata.gz: 095e05843eb3706414d810629f88d6e620564915
+  data.tar.gz: 12576a90db3eb7fb7378f214084f25847d114400
 SHA512:
-  metadata.gz: 64dc44b47c9cc66955f78064eb637a87745a501497c8ed6ef72df5edaf761352861e2c17bf4f643dfcc08ce170f1869fdf3d66b74d0ea5e88823efefb8666570
-  data.tar.gz: fc7cf4dc6056c95465635ed4f2c0daaacc2f7dcce3b5f66aa7c0ad17795afa620f7f73696cb12692864db94a91c4c8cdc2499ebfe368b50d109e099487362c8c
+  metadata.gz: aefd80b95d8ee2c56028fecb163ab635b20535e54657c2624707288fd738abc63242976c31da14d6fc592c6e4af30f004104e2c764340ed7f7476d9ec8640eb5
+  data.tar.gz: 9d195b673d48ed679cb00b82c737301253d55c9ad437a3c53031322a57e67fadb0b7146aa40f783752b085d66b6e5360cc1c38683932c4336497732900f1ed9a

data/lib/vagrant-windows-domain/provisioner.rb

@@ -20,13 +20,13 @@ module VagrantPlugins
       # Default path for storing the transient script runner
       WINDOWS_DOMAIN_GUEST_RUNNER_PATH = "c:/tmp/vagrant-windows-domain-runner.ps1"
       
-      attr_accessor :restart_sleep_duration        
+      attr_accessor :restart_sleep_duration
 
       # The current Computer Name.
       #
       # Used to determine whether or not we need to rename the computer 
       # on join. This parameter should not be manually set.
-      attr_accessor :old_computer_name      
+      attr_accessor :old_computer_name
 
       # Constructs the Provisioner Plugin.
       #
@@ -105,7 +105,9 @@ module VagrantPlugins
       def destroy
         if @config && @config.include?("domain")
           set_credentials
-          leave_domain
+          if leave_domain
+            restart_guest
+          end
         else
           @logger.debug("Not leaving domain on `destroy` action - no valid configuration detected")
           return
@@ -223,11 +225,19 @@ module VagrantPlugins
         @machine.ui.info(I18n.t(
           "vagrant_windows_domain.running"))
 
+        opts = {
+          elevated:    true,
+          error_check: true,
+          error_key:   nil, # use the error_class message key
+          good_exit:   0,
+          shell:       :powershell
+        }
+
         # A bit of an ugly dance, but this is how we get neat, colourised output and exit codes from a Powershell run
         last_type = nil
         new_line = ""
         error = false
-        machine.communicate.shell.powershell("powershell -ExecutionPolicy Bypass -OutputFormat Text -file #{script_path}") do |type, data|
+        machine.communicate.sudo("powershell -ExecutionPolicy Bypass -OutputFormat Text -file #{script_path}", opts) do |type, data|
           if !data.chomp.empty?
             error = true if type == :stderr
             if [:stderr, :stdout].include?(type)

data/lib/vagrant-windows-domain/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module WindowsDomain
-    VERSION = "1.1.9"
+    VERSION = "1.1.10"
   end
 end

data/spec/provisioner/leave_domain_spec.rb

@@ -10,7 +10,7 @@ describe VagrantPlugins::WindowsDomain::LeaveDomain do
   let(:instance) { described_class.new }
 
   let(:root_path)           { (Pathname.new(Dir.mktmpdir)).to_s }
-  let(:domain)				{ "foo.com" }
+  let(:domain)              { "foo.com" }
   let(:ui)                  { double("ui") }
   let(:app)                 { double("app") }
   let(:communicator)        { double ("communicator") }
@@ -19,9 +19,9 @@ describe VagrantPlugins::WindowsDomain::LeaveDomain do
   let(:guest)               { double ("guest") }
   let(:configuration_file)  { "manifests/MyWebsite.ps1" }
   let(:module_path)         { ["foo/modules", "foo/modules2"] }
-  let(:config)         		{ VagrantPlugins::WindowsDomain::Config.new }
+  let(:config)              { VagrantPlugins::WindowsDomain::Config.new }
   let(:vm)                  { double("vm", provisioners: [double("prov", config: config)]) }
-  let(:root_config)        	{ double("root_config", vm: vm) } 
+  let(:root_config)          { double("root_config", vm: vm) } 
   let(:env)                 { {:ui => ui, :machine => machine} }
   let(:machine)             { double("machine", ui: ui, id: "1234", config: root_config) }
   let(:provisioner)         { double("provisioner") }
@@ -34,7 +34,7 @@ describe VagrantPlugins::WindowsDomain::LeaveDomain do
       allow(env).to receive(:machine).and_return(machine)
       allow(communicator).to receive(:shell).and_return(shell)
       allow(shell).to receive(:powershell).and_yield(:stdout, "myoldcomputername")
-	  config.domain = domain
+      config.domain = domain
       allow(env).to receive(:machine).and_return(machine)
       allow(machine).to receive(:env).and_return(env)
       allow(env).to receive(:ui).and_return(ui)
@@ -42,91 +42,88 @@ describe VagrantPlugins::WindowsDomain::LeaveDomain do
     end
 
     context "when no configuration exists for the machine" do
-		it "should pass control to the next middleware Action" do
-			config.domain = nil
-			expect(app).to receive(:call).with(env)
-			subject.call(env)
-		end
+      it "should pass control to the next middleware Action" do
+        config.domain = nil
+        expect(app).to receive(:call).with(env)
+        subject.call(env)
+      end
     end
 
-  	context "when machine is running" do
-		it "should prompt the user if they would like to destroy & d/c the machine" do
-			state = double("state", id: :running)
-			expect(provisioner).to receive(:destroy)
+    context "when machine is running" do
+      it "should prompt the user if they would like to destroy & d/c the machine" do
+        state = double("state", id: :running)
+        expect(provisioner).to receive(:destroy)
 
-			expect(app).to receive(:call).with(env)
-      		expect(ui).to receive(:ask).with("Are you sure you want to destroy this machine and disconnect from #{domain}? (y/n)").and_return("y")
-			expect(machine).to receive(:state).and_return(state).twice
-			subject.call(env)
+        expect(app).to receive(:call).with(env)
+            expect(ui).to receive(:ask).with("Are you sure you want to destroy this machine and disconnect from #{domain}? (y/n)").and_return("y")
+        expect(machine).to receive(:state).and_return(state).twice
+        subject.call(env)
 
-		end
+      end
 
-		it "should not continue if the user declines to destroy the machine" do
-			state = double("state", id: :running)
-			expect(provisioner).to_not receive(:destroy)
+      it "should not continue if the user declines to destroy the machine" do
+        state = double("state", id: :running)
+        expect(provisioner).to_not receive(:destroy)
 
-            expect(ui).to receive(:ask).with("Are you sure you want to destroy this machine and disconnect from #{domain}? (y/n)").and_return("n")
-            expect(machine).to receive(:state).and_return(state).twice
-            expect(app).to_not receive(:call).with(env)
-            subject.call(env)
-
-		end
-  	end
-
-  	context "when machine is :paused, :saved or :poweroff" do
-		it "should prompt the user if they would like to force destroy the machine" do
-			state = double("state", id: :poweroff)
-			provisioner = double("provisioner")
-			subject.provisioner = provisioner
-
-      		expect(ui).to receive(:say).with(:warn, "Machine is currently not running. To properly leave the #{domain} network the machine needs to be running and connected to the network in which it was provisioned. Please run `vagrant up` and then `vagrant destroy`.\n")
-      		expect(ui).to receive(:ask).with("Would you like to continue destroying this machine, leaving this machine orphaned in the '#{domain}' network? (y/n)").and_return("y")
-      		expect(ui).to receive(:say).with(:warn, "Force destroying this machine and not leaving the domain foo.com. May FSM have mercy on your soul.")
-			expect(machine).to receive(:state).and_return(state).twice
-			expect(app).to receive(:call).with(env)
-			# Can't call destroy on a non-running machine
-			expect(provisioner).to_not receive(:destroy)
-
-			subject.call(env)
-
-			expect(env[:force_confirm_destroy]).to be(true)
-		end
-
-		it "should not pass on to middleware if user declines force destroy" do
-			state = double("state", id: :poweroff)
-			provisioner = double("provisioner")
-			subject.provisioner = provisioner
-
-      		expect(ui).to receive(:say).with(:warn, "Machine is currently not running. To properly leave the #{domain} network the machine needs to be running and connected to the network in which it was provisioned. Please run `vagrant up` and then `vagrant destroy`.\n")
-      		expect(ui).to receive(:ask).with("Would you like to continue destroying this machine, leaving this machine orphaned in the '#{domain}' network? (y/n)").and_return("n")
-			expect(machine).to receive(:state).and_return(state).twice
-			expect(app).to_not receive(:call).with(env)
-			expect(provisioner).to_not receive(:destroy)
-			expect(env[:force_confirm_destroy]).to be(nil)
-
-			subject.call(env)
-
-		end
-  	end
+        expect(ui).to receive(:ask).with("Are you sure you want to destroy this machine and disconnect from #{domain}? (y/n)").and_return("n")
+        expect(machine).to receive(:state).and_return(state).twice
+        expect(app).to_not receive(:call).with(env)
+        subject.call(env)
+      end
+    end
 
-  	context "when machine is :not_created" do
-  		it "should pass control to the next middleware action" do
-			state = double("state", id: :not_created)
-			expect(machine).to receive(:state).and_return(state)
+    context "when machine is :paused, :saved or :poweroff" do
+      it "should prompt the user if they would like to force destroy the machine" do
+        state = double("state", id: :poweroff)
+        provisioner = double("provisioner")
+        subject.provisioner = provisioner
+
+        expect(ui).to receive(:say).with(:warn, "Machine is currently not running. To properly leave the #{domain} network the machine needs to be running and connected to the network in which it was provisioned. Please run `vagrant up` and then `vagrant destroy`.\n")
+        expect(ui).to receive(:ask).with("Would you like to continue destroying this machine, leaving this machine orphaned in the '#{domain}' network? (y/n)").and_return("y")
+        expect(ui).to receive(:say).with(:warn, "Force destroying this machine and not leaving the domain foo.com. May FSM have mercy on your soul.")
+        expect(machine).to receive(:state).and_return(state).twice
+        expect(app).to receive(:call).with(env)
+        # Can't call destroy on a non-running machine
+        expect(provisioner).to_not receive(:destroy)
+
+        subject.call(env)
+
+        expect(env[:force_confirm_destroy]).to be(true)
+      end
+
+      it "should not pass on to middleware if user declines force destroy" do
+        state = double("state", id: :poweroff)
+        provisioner = double("provisioner")
+        subject.provisioner = provisioner
+
+        expect(ui).to receive(:say).with(:warn, "Machine is currently not running. To properly leave the #{domain} network the machine needs to be running and connected to the network in which it was provisioned. Please run `vagrant up` and then `vagrant destroy`.\n")
+        expect(ui).to receive(:ask).with("Would you like to continue destroying this machine, leaving this machine orphaned in the '#{domain}' network? (y/n)").and_return("n")
+        expect(machine).to receive(:state).and_return(state).twice
+        expect(app).to_not receive(:call).with(env)
+        expect(provisioner).to_not receive(:destroy)
+        expect(env[:force_confirm_destroy]).to be(nil)
+
+        subject.call(env)
+      end
+    end
 
-			expect(app).to receive(:call).with(env)
-			subject.call(env)
+    context "when machine is :not_created" do
+      it "should pass control to the next middleware action" do
+        state = double("state", id: :not_created)
+        expect(machine).to receive(:state).and_return(state)
 
-  		end
-  	end
+        expect(app).to receive(:call).with(env)
+        subject.call(env)
+      end
+    end
   end
 
 
   describe "initialize" do
 
-    its("env")            	{ should eq(env) }
-    its("app")     			{ should eq(app) }
-    its("config")          	{ should eq(config) }
+    its("env")              { should eq(env) }
+    its("app")              { should eq(app) }
+    its("config")           { should eq(config) }
     its("machine")          { should eq(machine) }
 
   end

data/spec/provisioner/provisioner_spec.rb

@@ -73,7 +73,7 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
     it "should join the domain" do
       allow(communicator).to receive(:upload)
       allow(ui).to receive(:info)
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell})
       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
       expect(machine).to receive(:action). with(:reload, {:provision_ignore_sentinel=>false})
       expect(communicator).to receive(:ready?).and_return(true)
@@ -85,7 +85,7 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
     it "should restart the machine on a successful domain join" do
       allow(communicator).to receive(:upload)
       allow(ui).to receive(:info)
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell})
       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
       expect(machine).to receive(:action). with(:reload, {:provision_ignore_sentinel=>false})
       expect(communicator).to receive(:ready?).and_return(true)
@@ -97,7 +97,7 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
       allow(communicator).to receive(:upload)
       allow(ui).to receive(:info).with("some exception thrown!", {:color=>:red, :new_line=>false, :prefix=>false}) # Red output on error please!
       allow(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1").and_yield(:stderr, "some exception thrown!")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell}).and_yield(:stderr, "some exception thrown!")
       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
       expect(machine).to_not receive(:action). with(:reload, {:provision_ignore_sentinel=>false})
       subject.restart_sleep_duration = 0
@@ -167,7 +167,7 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
     it "should leave domain" do
       allow(machine).to receive(:communicate).and_return(communicator)
       expect(communicator).to receive(:upload)
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1").and_yield(:stdout, "deleted")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell}).and_yield(:stdout, "deleted")
       expect(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
       expect(ui).to receive(:info).with("deleted", {:color=>:green, :new_line=>false, :prefix=>false})
       
@@ -177,13 +177,18 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
 
     it "should leave domain when a `vagrant destroy` is issued" do
       allow(machine).to receive(:communicate).and_return(communicator)
+
       expect(communicator).to receive(:upload)
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1").and_yield(:stdout, "deleted")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell}).and_yield(:stdout, "deleted")
       expect(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
       expect(ui).to receive(:info).with("deleted", {:color=>:green, :new_line=>false, :prefix=>false})
-
+      expect(ui).to receive(:say).with(:info, "Restarting computer for updates to take effect.")
+      expect(machine).to receive(:action). with(:reload, {:provision_ignore_sentinel=>false})
       expect(ui).to_not receive(:say)
       expect(ui).to_not receive(:ask)
+      expect(communicator).to receive(:ready?).and_return(true)
+      subject.restart_sleep_duration = 0      
+
       subject.destroy
     end
 
@@ -201,11 +206,17 @@ describe VagrantPlugins::WindowsDomain::Provisioner do
       root_config.password = nil
       allow(machine).to receive(:communicate).and_return(communicator)
       allow(machine).to receive(:env).and_return(env)
+
       expect(communicator).to receive(:upload)
-      expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1").and_yield(:stdout, "deleted")
+      expect(communicator).to receive(:sudo).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-windows-domain-runner.ps1", {:elevated=>true, :error_check=>true, :error_key=>nil, :good_exit=>0, :shell=>:powershell}).and_yield(:stdout, "deleted")
       expect(ui).to receive(:info).with(any_args).twice
       expect(ui).to receive(:ask).with("Please enter your domain password (output will be hidden): ", {:echo=>false}).and_return("myusername")
-      expect(ui).to receive(:ask).with("Please enter your domain username: ")      
+      expect(ui).to receive(:ask).with("Please enter your domain username: ")
+      expect(ui).to receive(:say).with(:info, "Restarting computer for updates to take effect.")
+      expect(machine).to receive(:action). with(:reload, {:provision_ignore_sentinel=>false})
+      expect(communicator).to receive(:ready?).and_return(true)
+      subject.restart_sleep_duration = 0
+
       subject.destroy
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-windows-domain
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.1.10
 platform: ruby
 authors:
 - Matt Fellows
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-12 00:00:00.000000000 Z
+date: 2015-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -199,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Windows Domain Provisioner for Vagrant