├── .gitignore
├── .travis.yml
├── Gemfile
├── LICENSE.txt
├── README.md
├── Rakefile
├── development
    └── Vagrantfile
├── lib
    ├── vagrant-windows-domain.rb
    └── vagrant-windows-domain
    │   ├── action
    │       └── leave_domain.rb
    │   ├── config.rb
    │   ├── locales
    │       └── en.yml
    │   ├── plugin.rb
    │   ├── provisioner.rb
    │   ├── templates
    │       └── runner.ps1.erb
    │   └── version.rb
├── spec
    ├── base.rb
    ├── provisioner
    │   ├── config_spec.rb
    │   └── provisioner_spec.rb
    └── spec_helper.rb
└── vagrant-windows-domain.gemspec


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.gem
 2 | *.rbc
 3 | .bundle
 4 | .config
 5 | .yardoc
 6 | Gemfile.lock
 7 | InstalledFiles
 8 | _yardoc
 9 | coverage
10 | doc/
11 | lib/bundler/man
12 | pkg
13 | rdoc
14 | spec/reports
15 | test/tmp
16 | test/version_tmp
17 | tmp
18 | *.bundle
19 | *.so
20 | *.o
21 | *.a
22 | mkmf.log
23 | .vagrant
24 | .idea


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: ruby
 2 | before_install:
 3 | - gem update --system
 4 | - gem install bundler
 5 | rvm:
 6 | - ruby-head
 7 | - 2.5.1
 8 | - 2.4.4
 9 | matrix:
10 |   allow_failures:
11 |   - rvm: ruby-head
12 |   fast_finish: true
13 | env:
14 |   matrix:
15 |   - VAGRANT_VERSION=v2.1.5
16 | script: bundle exec rake test:unit
17 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | source 'https://rubygems.org'
 2 | 
 3 | # Specify your gem's dependencies in vagrant-windows-domain.gemspec
 4 | gemspec
 5 | 
 6 | group :development do
 7 |   gem "vagrant", git: "https://github.com/mitchellh/vagrant.git", :tag => "v2.1.5"
 8 | end
 9 | 
10 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2014 Matt Fellows
 2 | 
 3 | MIT License
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | "Software"), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Vagrant Windows Domain Plugin
  2 | 
  3 | [![Build Status](https://travis-ci.org/SEEK-Jobs/vagrant-windows-domain.svg)](https://travis-ci.org/SEEK-Jobs/vagrant-windows-domain)
  4 | [![Coverage Status](https://coveralls.io/repos/SEEK-Jobs/vagrant-windows-domain/badge.svg?branch=master)](https://coveralls.io/r/SEEK-Jobs/vagrant-windows-domain?branch=master)
  5 | [![Gem Version](https://badge.fury.io/rb/vagrant-windows-domain.svg)](http://badge.fury.io/rb/vagrant-windows-domain)
  6 | 
  7 | A Vagrant Plugin that makes connecting and disconnecting your Windows Vagrant box to a Windows Domain a cinch.
  8 | 
  9 | On a `vagrant up` - unless credentials are supplied - it will prompt the user for their domain credentials and add the guest to the domain, including restarting the guest without interfering with other provisioners. 
 10 | 
 11 | On a `vagrant destroy`, it will do the same and remove itself from the Domain, keeping things neat-n-tidy.
 12 | 
 13 | ## Installation
 14 | 
 15 | ```vagrant plugin install vagrant-windows-domain```
 16 | 
 17 | ## Usage
 18 | 
 19 | In your Vagrantfile, add the following plugin and configure to your needs:
 20 | 
 21 | ```ruby
 22 | config.vm.provision :windows_domain do |domain|
 23 | 
 24 |     # The Windows Domain to join.
 25 |     #
 26 |     # Setting this will result in an additional restart.
 27 |     domain.domain = "domain.int"
 28 | 
 29 |     # The new Computer Name to use when joining the domain.
 30 |     #
 31 |     # Uses the Rename-Computer PowerShell command.
 32 |     # Specifies a new name for the computer in the new domain.
 33 |     domain.computer_name = "myfandangledname"
 34 | 
 35 |     # The Username to use when authenticating against the Domain.
 36 |     #
 37 |     # Specifies a user account that has permission to join the computers to a new domain. 
 38 |     #
 39 |     # If not supplied the plugin will prompt the user during provisioning to provide one.
 40 |     domain.username = "me"
 41 | 
 42 |     # The Password to use when authenticating against the Domain.
 43 |     #
 44 |     # Specifies the password of a user account that has permission to 
 45 |     # join the computers to a new domain. 
 46 |     #
 47 |     # If not supplied the plugin will prompt the user during provisioning to provide one.
 48 |     domain.password = "iprobablyshouldntusethisfield"
 49 | 
 50 |     # IP address of primary DNS server
 51 |     #
 52 |     # Specifies the IP address you want assigned as the primary DNS server for the primary nic.
 53 |     # If not supplied, the nic's primary dns server will be assigned dynamically.
 54 |     domain.primary_dns = "8.8.8.8"
 55 |     
 56 |     #IP address of the secondary DNS server
 57 |     #
 58 |     # Specifies the IP address you want assigned as the secondary DNS server for the primary nic
 59 |     # If not supplied, the nic's secondary dns server will be assigned dynamically.
 60 | 	domain.secondary_dns = "8.8.4.4"
 61 | 
 62 |     # The set of Advanced options to pass when joining the Domain.
 63 |     #
 64 |     # See (https://technet.microsoft.com/en-us/library/hh849798.aspx) for detail, these are generally not required.
 65 |     domain.join_options = [ "JoinReadOnly" ]
 66 | 
 67 |     # Organisational Unit path in AD.
 68 |     #
 69 |     # Specifies an organizational unit (OU) for the domain account. 
 70 |     # Enter the full distinguished name of the OU in quotation marks. 
 71 |     # The default value is the default OU for machine objects in the domain.
 72 |     domain.ou_path = "OU=testOU,DC=domain,DC=Domain,DC=com"
 73 | 
 74 |     # Performs an unsecure join to the specified domain.
 75 |     #
 76 |     # When this option is enabled username/password are not required and cannot be used.
 77 |     domain.unsecure = false
 78 | end
 79 | ```
 80 | ## Example
 81 | 
 82 | There is a [sample](https://github.com/SEEK-Jobs/vagrant-windows-domain/tree/master/development) Vagrant setup used for development of this plugin. 
 83 | This is a great real-life example to get you on your way.
 84 | 
 85 | ### Supported Environments
 86 | 
 87 | Currently the plugin supports any Windows environment with Powershell 3+ installed (2008r2, 2012r2 should work nicely).
 88 | 
 89 | ## Development
 90 | 
 91 | Before getting started, read the Vagrant plugin [development basics](https://docs.vagrantup.com/v2/plugins/development-basics.html) and [packaging](https://docs.vagrantup.com/v2/plugins/packaging.html) documentation.
 92 | 
 93 | You will need Ruby 2.1.5 and Bundler v1.12.5 installed before proceeding.
 94 | 
 95 | _NOTE_: it _must_ be bundler v1.12.5 due to a hard dependency in Vagrant at this time.
 96 | 
 97 | ```
 98 | git clone git@github.com:mefellows/vagrant-dsc.git
 99 | cd vagrant-dsc
100 | bundle install
101 | ```
102 | 
103 | Run tests:
104 | ```
105 | bundle exec rake spec
106 | ```
107 | 
108 | Run Vagrant in context of current vagrant-dsc plugin:
109 | ```
110 | cd <directory>
111 | bundle exec vagrant up
112 | ```
113 | 
114 | There is a test Vagrant DSC setup in `./development` that is a good example of a simple acceptance test.
115 | 
116 | ### Multiple Bundlers?
117 | 
118 | If you have multiple Bundler versions, you can still use 1.12.5 with the following:
119 | 
120 | ```
121 | bundle _1.12.5_ <command>
122 | ```
123 | 
124 | e.g. `bundle _1.12.5_ exec rake spec`
125 | 
126 | ## Uninstallation
127 | 
128 | ```vagrant plugin uninstall vagrant-windows-domain```
129 | 
130 | ## Contributing
131 | 
132 | 1. Fork it ( https://github.com/[my-github-username]/vagrant-windows-domain/fork )
133 | 2. Create your feature branch (`git checkout -b my-new-feature`)
134 | 3. Commit your changes (`git commit -am 'Add some feature'`)
135 | 4. Squash commits & push to the branch (`git push origin my-new-feature`)
136 | 5. Create a new Pull Request
137 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require "bundler/gem_tasks"
 2 | require 'rspec/core/rake_task'
 3 | task :default => [:test, :quality]
 4 | # Remove 'install' task as the gem is installed to Vagrant, not to system
 5 | Rake::Task[:install].clear
 6 | namespace :test do
 7 |   RSpec::Core::RakeTask.new('unit') do |task|
 8 |     task.pattern = 'spec/**/*_spec.rb'
 9 |   end
10 | end
11 | desc "Run all tests"
12 | task :test => ['test:unit']
13 | task :spec => :test


--------------------------------------------------------------------------------
/development/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | $shell_script = <<SCRIPT
 5 |   Write-Host "Hey, this happened after the restart!"
 6 | SCRIPT
 7 | 
 8 | # Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
 9 | VAGRANTFILE_API_VERSION = "2"
10 | 
11 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
12 | 
13 |   config.vm.box = "mfellows/windows2012r2"
14 |   config.vm.guest = :windows
15 |   config.vm.communicator = "winrm"
16 |   #ALlows for vagrant to successfully connect to destination machine with winrm 
17 |   config.vm.network :forwarded_port, guest: 5985, host: 55985 #, id: "winrm", auto_correct: true
18 | 
19 |   config.vm.provider "virtualbox" do |v| 
20 |     v.gui = true 
21 |   end
22 | 
23 |   # Run Windows Domain Provisioner
24 |   config.vm.provision :windows_domain do |domain|
25 | 
26 |     # The Windows Domain to join.
27 |     #
28 |     # Setting this will result in an additional restart.
29 |     domain.domain = "domain.int"
30 | 
31 |     # The new Computer Name to use when joining the domain.
32 |     #
33 |     # Uses the Rename-Computer PowerShell command. ORRRR -NewName flag??
34 |     # Specifies a new name for the computer in the new domain.
35 |     domain.computer_name = "myfandangledname"
36 | 
37 |     # The Username to use when authenticating against the Domain.
38 |     #
39 |     # Specifies a user account that has permission to join the computers to a new domain. 
40 |     domain.username = "me"
41 | 
42 |     # The Password to use when authenticating against the Domain.
43 |     #
44 |     # Specifies the password of a user account that has permission to 
45 |     # join the computers to a new domain. 
46 |     domain.password = "iprobablyshouldntusethisfield"
47 | 
48 |     # An array of advanced options to pass when joining the Domain.
49 |     #
50 |     # See (https://technet.microsoft.com/en-us/library/hh849798.aspx) for detail.
51 |     # NOTE: If we user :computer_name from above this needs to be merged!!
52 |     # domain.join_options = ['Win9xUpgrade']
53 | 
54 |     # Organisational Unit path in AD.
55 |     #
56 |     # Specifies an organizational unit (OU) for the domain account. 
57 |     # Enter the full distinguished name of the OU in quotation marks. 
58 |     # The default value is the default OU for machine objects in the domain.
59 |     # domain.ou_path = nil
60 | 
61 |     # Performs an unsecure join to the specified domain.
62 |     #
63 |     # When this option is used username/password are not required
64 |     domain.unsecure = false
65 |   end
66 | 
67 |   # Confirm that this will run after the reload from the domain provisioner!
68 |   config.vm.provision "shell", inline: $shell_script  
69 | end
70 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain.rb:
--------------------------------------------------------------------------------
 1 | require "pathname"
 2 | 
 3 | require "vagrant-windows-domain/plugin"
 4 | 
 5 | module VagrantPlugins
 6 |   module WindowsDomain
 7 |     lib_path = Pathname.new(File.expand_path("../vagrant-windows-domain", __FILE__))
 8 |     autoload :Action, lib_path.join("action")
 9 |     autoload :Errors, lib_path.join("errors")
10 | 
11 |     # This returns the path to the source of this plugin.
12 |     #
13 |     # @return [Pathname]
14 |     def self.source_root
15 |       @source_root ||= Pathname.new(File.expand_path("../lib", __FILE__))
16 |     end
17 |   end
18 | end
19 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/action/leave_domain.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../provisioner'
 2 | 
 3 | module VagrantPlugins
 4 |   module WindowsDomain
 5 |     # Include the built-in modules so we can use them as top-level things.
 6 |     include Vagrant::Action::Builtin
 7 | 
 8 |     # Leave a domain on a `vagrant destroy`.
 9 |     #
10 |     # This is an Action middleware component that will detect the state of the machine -
11 |     # and any corresponding configuration and act accordingly. This function accepts user input and
12 |     # will halt the execution of proceeding middleware if the user chooses to cancel.
13 |     #
14 |     # Also note that it will interfere with a `vagrant destroy` user input to avoid duplicate "are you sure.."
15 |     # messages.
16 |     class LeaveDomain
17 |       include VagrantPlugins::WindowsDomain
18 | 
19 |       attr_accessor :machine
20 |       attr_accessor :config
21 |       attr_accessor :env
22 |       attr_accessor :app
23 |       attr_accessor :provisioner
24 | 
25 |       def initialize(app, env)
26 |         @logger = Log4r::Logger.new("vagrant::provisioners::vagrant_windows_domain")
27 |         @logger.debug("Initialising WindowsDomain plugin on destroy action")
28 |         @app = app
29 |         @env = env
30 |         @machine = env[:machine]
31 | 
32 |         @machine.config.vm.provisioners.each do |prov|
33 |           @config = prov.config if prov.config.is_a?(VagrantPlugins::WindowsDomain::Config)
34 |         end
35 | 
36 |         @provisioner = VagrantPlugins::WindowsDomain::Provisioner.new(@machine, @config)
37 |       end
38 | 
39 |       # The middleware method that is invoked automatically by the Plugin ecosystem.
40 |       # Expected to call the next middleware component in the chain if action should proceed.
41 |       def call(env)
42 | 
43 |         if @config and @config.domain != nil
44 | 
45 |        	  if [:not_created].include? @machine.state.id
46 |        	    @logger.debug("Machine not created, nothing to do")
47 |        	  elsif [:running].include? @machine.state.id
48 |             if !(env[:force_confirm_box_remove] || env[:force_confirm_destroy])
49 |        	      answer = @machine.env.ui.ask("Are you sure you want to destroy this machine and disconnect from #{@config.domain}? (y/n)")
50 |               return unless answer.downcase == 'y' # Bail out of destroy and prevent middleware from continuing on
51 |             end 
52 | 
53 |             env[:force_confirm_destroy] = true # Prevent the popup dialog again
54 |             @logger.debug("Valid configuration detected, triggering leave domain action")
55 |             @provisioner.destroy
56 |        	  else
57 |        	    @machine.env.ui.say(:warn, "Machine is currently not running. To properly leave the #{@config.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")
58 |             if !(env[:force_confirm_box_remove] || env[:force_confirm_destroy])
59 |        	      answer = @machine.env.ui.ask("Would you like to continue destroying this machine, leaving this machine orphaned in the '#{@config.domain}' network? If so, type 'destroy'")
60 |        	      return unless answer.downcase == 'destroy' # Bail out of destroy and prevent middleware from continuing on
61 |             end 
62 | 
63 |        	    # OK, we're being naughty and letting the rest of the middleware do their things (i.e. destroy the machine, and such)
64 | 
65 |        	    env[:force_confirm_destroy] = true # Prevent the popup dialog again
66 |        	    @logger.debug("Force destroying this machine and not leaving the domain #{@config.domain}")
67 |        	    @machine.env.ui.say(:warn, "Force destroying this machine and not leaving the domain #{@config.domain}. May FSM have mercy on your soul.")
68 |        	  end
69 |        	else
70 |        	  @logger.debug("No configuration detected, not leaving any domain")
71 |        	end
72 | 
73 |         # Continue the rest of the middleware actions
74 |         @app.call(env)
75 |       end
76 | 
77 |     end
78 |   end
79 | end
80 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/config.rb:
--------------------------------------------------------------------------------
  1 | require "vagrant/util/counter"
  2 | require "log4r"
  3 | 
  4 | module VagrantPlugins
  5 |   module WindowsDomain    
  6 |     # The "Configuration" represents a configuration of how the WindowsDomain
  7 |     # provisioner should behave: authentication mechanism etc.
  8 |     class Config < Vagrant.plugin("2", :config)
  9 | 
 10 |       # The Windows Domain to join.
 11 |       #
 12 |       # Setting this will result in an additional restart.
 13 |       attr_accessor :domain
 14 | 
 15 |       # The new Computer Name to use when joining the domain.
 16 |       # Specifies a new name for the computer in the new domain. Uses the -NameName Option.
 17 |       attr_accessor :computer_name
 18 | 
 19 |       # The Username to use when authenticating against the Domain.
 20 |       #
 21 |       # Specifies a user account that has permission to join the computers to a new domain. 
 22 |       attr_accessor :username
 23 | 
 24 |       # The Password to use when authenticating against the Domain.
 25 |       #
 26 |       # Specifies the password of a user account that has permission to 
 27 |       # join the computers to a new domain. 
 28 |       attr_accessor :password
 29 | 
 30 |       # The set of Advanced options to pass when joining the Domain.
 31 |       #
 32 |       # See (https://technet.microsoft.com/en-us/library/hh849798.aspx) for detail.
 33 |       # NOTE: If we user :computer_name from above this needs to be merged!!
 34 |       attr_accessor :join_options
 35 | 
 36 |       # Organisational Unit path in AD.
 37 |       #
 38 |       # Specifies an organizational unit (OU) for the domain account. 
 39 |       # Enter the full distinguished name of the OU in quotation marks. 
 40 |       # The default value is the default OU for machine objects in the domain.
 41 |       attr_accessor :ou_path
 42 | 
 43 |       # IP address of primary DNS server
 44 |       #
 45 |       # Specifies the IP address you want assigned as the primary DNS server for the primary nic
 46 |       attr_accessor :primary_dns
 47 | 
 48 |       #IP address of the secondary DNS server
 49 |       #
 50 |       # Specifies the IP address you want assigned as the secondary DNS server for the primary nic
 51 |       attr_accessor :secondary_dns
 52 | 
 53 |       # Performs an unsecure join to the specified domain.
 54 |       #
 55 |       # When this option is used username/password are not required
 56 |       attr_accessor :unsecure
 57 | 
 58 |       # The trigger whether plugin should rename the computer or omit the renaming
 59 |       attr_accessor :rename
 60 | 
 61 |       def initialize
 62 |         super
 63 |         @domain            = UNSET_VALUE
 64 |         @computer_name     = UNSET_VALUE
 65 |         @username          = UNSET_VALUE
 66 |         @password          = UNSET_VALUE
 67 |         @join_options      = {}
 68 |         @ou_path           = UNSET_VALUE
 69 |         @primary_dns       = UNSET_VALUE
 70 |         @secondary_dns     = UNSET_VALUE
 71 |         @unsecure          = UNSET_VALUE
 72 |         @rename            = UNSET_VALUE
 73 |         @logger            = Log4r::Logger.new("vagrant::vagrant_windows_domain")
 74 |       end
 75 | 
 76 |       # Final step of the Configuration lifecyle prior to
 77 |       # validation.
 78 |       # 
 79 |       # Ensures all attributes are set to defaults if not provided.
 80 |       def finalize!
 81 |         super
 82 | 
 83 |         # Null checks
 84 |         @domain            = nil if @domain == UNSET_VALUE || @domain == ""
 85 |         @computer_name     = nil if @computer_name == UNSET_VALUE || @computer_name == ""
 86 |         @username          = nil if @username == UNSET_VALUE || @username == ""
 87 |         @password          = nil if @password == UNSET_VALUE || @password == ""
 88 |         @join_options      = [] if @join_options == UNSET_VALUE
 89 |         @ou_path           = nil if @ou_path == UNSET_VALUE
 90 |         @primary_dns       = nil if @primary_dns == UNSET_VALUE || @primary_dns == ""
 91 |         @secondary_dns     = nil if @secondary_dns == UNSET_VALUE || @secondary_dns == ""
 92 |         @unsecure          = false if @unsecure == UNSET_VALUE
 93 |         @rename            = false if @rename == UNSET_VALUE
 94 |       end
 95 | 
 96 |       # Validate configuration and return a hash of errors.
 97 |       #
 98 |       # Validation happens after finalize!.
 99 |       #
100 |       # @param [Machine] The current {Machine}
101 |       # @return [Hash] Any errors or {} if no errors found
102 |       def validate(machine)        
103 |         errors = _detected_errors
104 | 
105 |         # Need to supply one of them!
106 |         if (@username != nil && @password != nil) && @unsecure == true
107 |           errors << I18n.t("vagrant_windows_domain.errors.both_credentials_provided")
108 |         end
109 | 
110 |         if @secondary_dns != nil && @primary_dns == nil
111 |           errors << I18n.t("vagrant_windows_domain.errors.invalid_dns_config")
112 |         end
113 |         
114 |         { "windows domain provisioner" => errors }
115 |       end     
116 |     end
117 |   end
118 | end
119 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/locales/en.yml:
--------------------------------------------------------------------------------
 1 | en:
 2 |   vagrant_windows_domain:
 3 |     already_status: |-
 4 |       The machine is already %{status}.
 5 | 
 6 |     running: |-
 7 |       "Running Windows Domain Provisioner"
 8 | 
 9 |     errors:
10 |       unsupported_platform: |-
11 |         Unsupported platform detected. Vagrant Windows Domain only works on Windows guest environments.
12 |       both_credentials_provided: |-
13 |         You must not supply a "username" and "password" if "unsecure" is set to true.
14 |       binary_not_detected: |-
15 |         "The command '%{binary} required to join/remove the guest machine from the domain '%{domain}' was not found on the guest machine"
16 |       absolute_module_path: |-
17 |         "Absolute 'module_path' not allowed. Please provide a path relative to your Vagrantfile."
18 |       invalid_dns_config: |-
19 |         "Primary dns must be set before configuring Secondary DNS."


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/plugin.rb:
--------------------------------------------------------------------------------
 1 | require "vagrant"
 2 | 
 3 | module VagrantPlugins
 4 |   module WindowsDomain
 5 |     class Plugin < Vagrant.plugin("2")
 6 |       name "DSC"
 7 |       description <<-DESC
 8 |         Provides support for adding and removing guest Windows machines
 9 |         from a Domain.
10 |       DESC
11 | 
12 |       config(:windows_domain, :provisioner) do
13 |         require_relative 'config'
14 |         Config
15 |       end
16 |       
17 |       config(:windows_domain) do
18 |         require_relative 'config'
19 |         Config
20 |       end
21 | 
22 |       provisioner(:windows_domain) do
23 |         require_relative 'provisioner'
24 |         Provisioner
25 |       end
26 | 
27 |   #    action_hook(:windows_domain, :machine_action_destroy) do |hook|
28 |    #     require_relative 'action/leave_domain'
29 |    #     hook.prepend(VagrantPlugins::WindowsDomain::LeaveDomain)
30 |    #   end
31 |     end
32 |   end
33 | end


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/provisioner.rb:
--------------------------------------------------------------------------------
  1 | require "log4r"
  2 | require 'erb'
  3 | 
  4 | module VagrantPlugins
  5 |   module WindowsDomain
  6 |     # DSC Errors namespace, including setup of locale-based error messages.
  7 |     class WindowsDomainError < Vagrant::Errors::VagrantError
  8 |       error_namespace("vagrant_windows_domain.errors")
  9 |       I18n.load_path << File.expand_path("locales/en.yml", File.dirname(__FILE__))
 10 |     end
 11 |     class DSCUnsupportedOperation < WindowsDomainError
 12 |       error_key(:unsupported_operation)
 13 |     end    
 14 | 
 15 |     # Windows Domain Provisioner Plugin.
 16 |     #
 17 |     # Connects and Removes a guest Machine from a Windows Domain.
 18 |     class Provisioner < Vagrant.plugin("2", :provisioner)
 19 | 
 20 |       # Default path for storing the transient script runner
 21 |       WINDOWS_DOMAIN_GUEST_RUNNER_PATH = "c:/tmp/vagrant-windows-domain-runner.ps1"
 22 |       
 23 |       attr_accessor :restart_sleep_duration
 24 | 
 25 |       # The current Computer Name.
 26 |       #
 27 |       # Used to determine whether or not we need to rename the computer 
 28 |       # on join. This parameter should not be manually set.
 29 |       attr_accessor :old_computer_name
 30 | 
 31 |       # Constructs the Provisioner Plugin.
 32 |       #
 33 |       # @param [Machine] machine The guest machine that is to be provisioned.
 34 |       # @param [Config] config The Configuration object used by the Provisioner.
 35 |       # @returns Provisioner
 36 |       def initialize(machine, config)
 37 |         super
 38 | 
 39 |         @logger = Log4r::Logger.new("vagrant::provisioners::vagrant_windows_domain")
 40 |         @restart_sleep_duration = 10
 41 |       end
 42 | 
 43 |       # Configures the Provisioner.
 44 |       #
 45 |       # @param [Config] root_config The default configuration from the Vagrant hierarchy.
 46 |       def configure(root_config)
 47 |         raise WindowsDomainError, :unsupported_platform if !windows?
 48 |       end
 49 | 
 50 | 
 51 |       def is_part_of_domain(computer_name, domain)
 52 |         command = <<-EOH
 53 |           function Test-PartOfDomain($computerName, $domain){
 54 |             $computerSystem = gwmi win32_computersystem
 55 |             $partofDomain = ($computerSystem.Name -eq $computerName) -and ($computerSystem.PartOfDomain) -and ($computerSystem.Domain -eq $domain) 
 56 | 
 57 |             if ($partofDomain) {
 58 |               exit 0
 59 |             } else {
 60 |               exit 1
 61 |             }
 62 |           }
 63 |           Test-PartOfDomain -computerName '#{computer_name}' -domain '#{domain}'
 64 |         EOH
 65 |         @machine.communicate.test(command, sudo: true)
 66 |       end
 67 | 
 68 |       def is_joined_to_domain()
 69 |         command = <<-EOH
 70 |           function Test-JoinedToADomain(){
 71 |             $computerSystem = gwmi win32_computersystem
 72 |             $partOfDomain = $computerSystem.PartOfDomain
 73 |             if ($partofDomain) {
 74 |               exit 0
 75 |             } else {
 76 |               exit 1
 77 |             }
 78 |           }
 79 |           Test-JoinedToADomain
 80 |         EOH
 81 |         @machine.communicate.test(command, sudo: true)
 82 |       end
 83 | 
 84 | 
 85 |       # Run the Provisioner!
 86 |       def provision
 87 |         verify_guest_capability
 88 | 
 89 |         @old_computer_name = get_guest_computer_name(machine)
 90 | 
 91 |         result = is_part_of_domain(config.computer_name, config.domain)
 92 | 
 93 |         if result
 94 |           @machine.env.ui.say(:info, "Guest machine with computer name '#{config.computer_name}' is already a member of domain '#{config.domain}'")
 95 |         else
 96 |           @machine.env.ui.say(:info, "Connecting guest machine to domain '#{config.domain}' with computer name '#{config.computer_name}'")
 97 | 
 98 |           set_credentials
 99 | 
100 |           result = join_domain
101 | 
102 |           remove_command_runner_script
103 | 
104 |           if result
105 |             #Often requires 2 reboots to ensure that all AD stuff has been applied
106 |             @logger.debug("Need to reboot to join the domain correctly - 1st reboot")
107 |             restart_guest
108 | 
109 |             @logger.debug("Need to reboot to join the domain correctly - 2nd reboot")
110 |             #restart_guest
111 |           end
112 |         end
113 |       end
114 | 
115 |       # Join the guest machine to a Windows Domain.
116 |       #
117 |       # Generates, writes and runs a script to join a domain.
118 |       def join_domain        
119 |         run_remote_command_runner(write_command_runner_script(generate_command_runner_script(true)))
120 |       end
121 | 
122 |       # Removes the guest machine from a Windows Domain.
123 |       #
124 |       # Generates, writes and runs a script to leave a domain.
125 |       def leave_domain
126 |         run_remote_command_runner(write_command_runner_script(generate_command_runner_script(false)))
127 |       end
128 |       alias_method :unjoin_domain, :leave_domain
129 | 
130 |       # Ensure credentials are provided.
131 |       #
132 |       # Get username/password from user if not provided
133 |       # as part of the config.
134 |       def set_credentials
135 |         if (config.username == nil)
136 |           @logger.info("==> Requesting username as none provided")
137 |           config.username = @machine.env.ui.ask("Please enter your domain username: ")
138 |         else
139 |           @logger.info("==> Using domain username: #{config.username}")
140 |         end
141 | 
142 |         if (config.password == nil)
143 |           @logger.info("==> Requesting password as none provided")
144 |           config.password = @machine.env.ui.ask("Please enter your domain password (output will be hidden): ", {:echo => false})
145 |         end
146 |       end
147 | 
148 |       # Cleanup after a destroy action.
149 |       #
150 |       # This is the method called when destroying a machine that allows
151 |       # for any state related to the machine created by the provisioner
152 |       # to be cleaned up.
153 |       def cleanup
154 |         if @config && @config.domain != nil
155 |           if is_joined_to_domain()
156 |             set_credentials
157 |             result = leave_domain
158 |             if result
159 |               @logger.debug("Need to reboot to leave the domain correctly")
160 |               #restart_guest
161 |             end
162 |           end
163 |         else
164 |           @logger.debug("Not leaving domain on `destroy` action - no valid configuration detected")
165 |           return
166 |         end
167 |       end
168 | 
169 |       # Restarts the Computer and waits
170 |       def restart_guest
171 |         @machine.env.ui.say(:info, "Restarting computer for updates to take effect.")
172 |         options = {}
173 |         options[:provision_ignore_sentinel] = false
174 |         options[:lock] = false
175 |         @machine.action(:reload, options)
176 |         Timeout.timeout(@machine.config.vm.boot_timeout) do
177 |           begin
178 |             sleep @restart_sleep_duration
179 |           end until @machine.communicate.ready?
180 |         end
181 |       end
182 | 
183 |       # Verify that we can call the remote operations.
184 |       # Required to add the computer to a Domain.
185 |       def verify_guest_capability
186 |         verify_binary("Add-Computer")
187 |         verify_binary("Remove-Computer")
188 |       end
189 | 
190 |       # Verify a binary\command is executable on the guest machine.
191 |       def verify_binary(binary)
192 |         @machine.communicate.sudo(
193 |           "which #{binary}",
194 |           error_class: WindowsDomainError,
195 |           error_key: :binary_not_detected,
196 |           domain: config.domain,
197 |           binary: binary)
198 |       end
199 | 
200 |       # Generates a PowerShell runner script from an ERB template
201 |       #
202 |       # @param [boolean] add_to_domain Whether or not to add or remove the computer to the domain (default: true).
203 |       # @return [String] The interpolated PowerShell script.
204 |       def generate_command_runner_script(add_to_domain=true)
205 |         path = File.expand_path("../templates/runner.ps1", __FILE__)
206 | 
207 |         if @config.computer_name != nil && @old_computer_name != nil && @config.computer_name.casecmp(@old_computer_name) != 0
208 |           @config.rename = true
209 |         end
210 |         
211 |         Vagrant::Util::TemplateRenderer.render(path, options: {
212 |             config: @config,
213 |             username: @config.username,
214 |             password: @config.password,
215 |             domain: @config.domain,
216 |             computer_name: @config.computer_name,
217 |             ou_path: @config.ou_path,
218 |             primary_dns: @config.primary_dns,
219 |             secondary_dns: @config.secondary_dns,
220 |             add_to_domain: add_to_domain,
221 |             unsecure: @config.unsecure,
222 |             rename: @config.rename,
223 |             parameters: generate_command_arguments(add_to_domain)
224 |         }, options_rename: {
225 |             parameters: generate_command_arguments_rename
226 |         })
227 |       end
228 | 
229 |       # Generates the argument list for rename 
230 |       def generate_command_arguments_rename
231 | 
232 |         params = {"-NewName" => @config.computer_name}
233 |         params["-DomainCredential $credentials"] = nil
234 |         join_params = @config.join_options.map { |a| "#{a}" }.join(',')
235 |         params.map { |k,v| "#{k}" + (!v.nil? ? " #{v}": '') }.join(' ') + join_params
236 |         
237 |       end
238 |       
239 |       # Generates the argument list
240 |       def generate_command_arguments(add_to_domain=true)
241 | 
242 |         if add_to_domain
243 |           params = {"-DomainName" => @config.domain }
244 | 
245 |           if @config.unsecure
246 |             params["-Unsecure"] = nil
247 |           else
248 |             params["-Credential $credentials"] = nil
249 |           end
250 | 
251 |           if @config.ou_path
252 |             params["-OUPath"] = "'#{@config.ou_path}'"
253 |           end
254 | 
255 |           # Remove with unsecure
256 |           join_params = @config.join_options.map { |a| "#{a}" }.join(',')
257 |           if join_params.to_s != ''
258 |             params["-Options"] = join_params
259 |           end
260 |         else
261 |           params = {}
262 |           if !@config.unsecure
263 |             params["-UnjoinDomainCredential $credentials"] = nil
264 |           end
265 |         end
266 | 
267 |         params.map { |k,v| "#{k}" + (!v.nil? ? " #{v}": '') }.join(' ')
268 |       end
269 | 
270 |       # Writes the PowerShell runner script to a location on the guest.
271 |       #
272 |       # @param [String] script The PowerShell runner script.
273 |       # @return [String] the Path to the uploaded location on the guest machine.
274 |       def write_command_runner_script(script)
275 |         guest_script_path = WINDOWS_DOMAIN_GUEST_RUNNER_PATH
276 |         file = Tempfile.new(["vagrant-windows-domain-runner", "ps1"])
277 |         begin
278 |           file.write(script)
279 |           file.fsync
280 |           file.close
281 |           @machine.communicate.upload(file.path, guest_script_path)
282 |         ensure
283 |           file.close
284 |           file.unlink
285 |         end
286 |         guest_script_path
287 |       end
288 | 
289 |       # Remove temporary run script as it may contain
290 |       # sensitive plain-text credentials.
291 |       def remove_command_runner_script
292 |         @machine.communicate.sudo("del #{WINDOWS_DOMAIN_GUEST_RUNNER_PATH}")
293 |       end
294 | 
295 |       # Runs the PowerShell script on the guest machine.
296 |       #
297 |       # Streams the output of the command to the UI
298 |       # @return [boolean] The result of the remote command
299 |       def run_remote_command_runner(script_path)
300 |         @machine.ui.info(I18n.t(
301 |           "vagrant_windows_domain.running"))
302 | 
303 |         opts = {
304 |           elevated:    true,
305 |           error_check: true,
306 |           error_key:   nil, # use the error_class message key
307 |           good_exit:   0,
308 |           shell:       :powershell
309 |         }
310 | 
311 |         # A bit of an ugly dance, but this is how we get neat, colourised output and exit codes from a Powershell run
312 |         last_type = nil
313 |         new_line = ""
314 |         error = false
315 |         exit_status = @machine.communicate.sudo("powershell -ExecutionPolicy Bypass -OutputFormat Text -file #{script_path}", opts) do |type, data|
316 |           if !data.chomp.empty?
317 |             error = true if type == :stderr
318 |             if [:stderr, :stdout].include?(type)
319 |               color = type == :stdout ? :green : :red
320 |               new_line = "\r\n" if last_type != nil and last_type != type
321 |               last_type = type
322 |               @machine.ui.info( new_line + data.chomp, color: color, new_line: false, prefix: false)
323 |             end
324 |           end
325 |         end
326 | 
327 |         error == false
328 |       end
329 | 
330 |       # Gets the Computer Name from the guest machine
331 |       def get_guest_computer_name(machine)
332 |         computerName = ""
333 |         machine.communicate.shell.powershell("$env:COMPUTERNAME") do |type, data|
334 |           if !data.chomp.empty?
335 |             if [:stderr, :stdout].include?(type)
336 |               computerName = data.chomp
337 |               @logger.info("Detected guest computer name: #{computerName}")
338 |             end
339 |           end
340 |         end
341 | 
342 |         computerName
343 |       end 
344 | 
345 |       # Is the guest Windows?
346 |       def windows?
347 |         # If using WinRM, we can assume we are on Windows
348 |         @machine.config.vm.communicator == :winrm
349 |       end
350 | 
351 |     end
352 |   end
353 | end
354 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/templates/runner.ps1.erb:
--------------------------------------------------------------------------------
  1 | function Test-PartOfDomain($computerName, $domain){
  2 | 	$computerSystem = gwmi win32_computersystem
  3 | 	return ($computerSystem.Name -eq $computerName) -and ($computerSystem.PartOfDomain) -and ($computerSystem.Domain -eq $domain) 
  4 | }
  5 | 
  6 | function Test-JoinedToADomain(){
  7 | 	$computerSystem = gwmi win32_computersystem
  8 | 	return $computerSystem.PartOfDomain
  9 | }
 10 | 
 11 | function Repair-OpenSSHPasswd(){
 12 | 	$passwdPath = 'C:\Program Files\OpenSSH\etc\passwd'
 13 | 	$mkpasswdPath = 'C:\Program Files\OpenSSH\bin\mkpasswd.exe'
 14 | 	if ((Test-Path $passwdPath) -and (Test-Path $mkpasswdPath)){
 15 | 		$passwd = &$mkpasswdPath
 16 | 		$passwd = $passwd -replace '^([^+]*\+)', ''
 17 | 		$passwd | Set-Content $passwdPath -Encoding Ascii
 18 | 	}
 19 | }
 20 | function New-ADSIPrincipalContext
 21 | {
 22 | 	[CmdletBinding(SupportsShouldProcess = $true)]
 23 | 	[OutputType('System.DirectoryServices.AccountManagement.PrincipalContext')]
 24 | 	PARAM
 25 | 	(
 26 | 		[Alias("RunAs")]
 27 | 		[System.Management.Automation.PSCredential]
 28 | 		[System.Management.Automation.Credential()]
 29 | 		$Credential = [System.Management.Automation.PSCredential]::Empty,
 30 | 		
 31 | 		[Parameter(Mandatory = $true)]
 32 | 		[System.DirectoryServices.AccountManagement.ContextType]$ContextType,
 33 | 		
 34 | 		$DomainName = [System.DirectoryServices.ActiveDirectory.Domain]::Getcurrentdomain(),
 35 | 		
 36 | 		$Container,
 37 | 		
 38 | 		[System.DirectoryServices.AccountManagement.ContextOptions[]]$ContextOptions
 39 | 	)
 40 | 	
 41 | 	BEGIN
 42 | 	{
 43 | 		$ScriptName = (Get-Variable -name MyInvocation -Scope 0 -ValueOnly).MyCommand
 44 | 		Write-Verbose -Message "[$ScriptName] Add Type System.DirectoryServices.AccountManagement"
 45 | 		Add-Type -AssemblyName System.DirectoryServices.AccountManagement
 46 | 	}
 47 | 	PROCESS
 48 | 	{
 49 | 		TRY
 50 | 		{
 51 | 			switch ($ContextType)
 52 | 			{
 53 | 				"Domain" { $ArgumentList = $ContextType, $DomainName }
 54 | 				"Machine" { $ArgumentList = $ContextType, $ComputerName }
 55 | 				"ApplicationDirectory" { $ArgumentList = $ContextType }
 56 | 			}
 57 | 			
 58 | 			IF ($PSBoundParameters['Container'])
 59 | 			{
 60 | 				$ArgumentList += $Container
 61 | 			}
 62 | 			
 63 | 			IF ($PSBoundParameters['ContextOptions'])
 64 | 			{
 65 | 				$ArgumentList += $($ContextOptions)
 66 | 			}
 67 | 			
 68 | 			IF ($PSBoundParameters['Credential'])
 69 | 			{
 70 | 				# Query the specified domain or current if not entered, with the specified credentials
 71 | 				$ArgumentList += $($Credential.UserName), $($Credential.GetNetworkCredential().password)
 72 | 			}
 73 | 			
 74 | 			IF ($PSCmdlet.ShouldProcess($DomainName, "Create Principal Context"))
 75 | 			{
 76 | 				# Query 
 77 | 				New-Object -TypeName System.DirectoryServices.AccountManagement.PrincipalContext -ArgumentList $ArgumentList
 78 | 			}
 79 | 		} #TRY
 80 | 		CATCH
 81 | 		{
 82 | 			$PSCmdlet.ThrowTerminatingError($_)
 83 | 		}
 84 | 	} #PROCESS
 85 | }
 86 | 
 87 | function Get-ADSIComputer
 88 | {
 89 | 	[CmdletBinding(DefaultParameterSetName="All")]
 90 | 	param ([Parameter(Mandatory=$true,ParameterSetName="Identity")]
 91 | 		[string]$Identity,
 92 | 		
 93 | 		[Alias("RunAs")]
 94 | 		[System.Management.Automation.PSCredential]
 95 | 		[System.Management.Automation.Credential()]
 96 | 		$Credential = [System.Management.Automation.PSCredential]::Empty,
 97 | 
 98 | 		[String]$DomainName
 99 | 	)
100 | 	BEGIN
101 | 	{
102 |         Add-Type -AssemblyName System.DirectoryServices.AccountManagement
103 | 		
104 |         # Create Context splatting
105 |         $ContextSplatting = @{ ContextType = "Domain" }
106 | 		
107 |         IF ($PSBoundParameters['Credential']) { $ContextSplatting.Credential = $Credential }
108 |         IF ($PSBoundParameters['DomainName']) { $ContextSplatting.DomainName = $DomainName }
109 | 		
110 |         $Context = New-ADSIPrincipalContext @ContextSplatting
111 | 
112 | 	}
113 | 	PROCESS
114 | 	{
115 |         TRY{
116 |             IF($Identity)
117 |             {
118 |                 [System.DirectoryServices.AccountManagement.ComputerPrincipal]::FindByIdentity($Context, $Identity)
119 |             }
120 |             ELSE{
121 |                 $ComputerPrincipal = New-object -TypeName System.DirectoryServices.AccountManagement.ComputerPrincipal -ArgumentList $Context
122 | 			    $Searcher = new-object System.DirectoryServices.AccountManagement.PrincipalSearcher
123 | 			    $Searcher.QueryFilter = $ComputerPrincipal
124 | 
125 |                 $Searcher.FindAll()
126 |             }
127 |         }
128 |         CATCH
129 |         {
130 |         	$pscmdlet.ThrowTerminatingError($_)
131 |         }
132 | 	}
133 | }
134 | 
135 | function Remove-ADSIComputer
136 | {
137 | 	[CmdletBinding(SupportsShouldProcess = $true)]
138 | 	PARAM (
139 | 		[parameter(Mandatory = $true, ValueFromPipelineByPropertyName = $true, ValueFromPipeline = $true)]
140 | 		$Identity,
141 | 
142 | 		[Alias("RunAs")]
143 | 		[System.Management.Automation.PSCredential]
144 | 		[System.Management.Automation.Credential()]
145 | 		$Credential = [System.Management.Automation.PSCredential]::Empty,
146 | 
147 | 		[String]$DomainName,
148 | 
149 | 		[Switch]$Recursive
150 | 	)
151 | 	
152 | 	BEGIN
153 | 	{
154 | 		Add-Type -AssemblyName System.DirectoryServices.AccountManagement
155 | 		
156 | 		# Create Context splatting
157 | 		$ContextSplatting = @{ }
158 | 		IF ($PSBoundParameters['Credential']) { $ContextSplatting.Credential = $Credential }
159 | 		IF ($PSBoundParameters['DomainName']) { $ContextSplatting.DomainName = $DomainName }
160 | 
161 | 	}
162 | 	PROCESS
163 | 	{
164 | 		TRY
165 | 		{
166 | 			# Not Recursive
167 | 			if (-not $PSBoundParameters['Recursive'])
168 | 			{
169 | 				if ($pscmdlet.ShouldProcess("$Identity", "Remove Account"))
170 | 				{
171 | 					$Account = Get-ADSIComputer -Identity $Identity @ContextSplatting
172 | 					$Account.delete()
173 | 				}
174 | 			}
175 | 			
176 | 			# Recursive (if the computer is the parent of one leaf or more)
177 | 			if ($PSBoundParameters['Recursive'])
178 | 			{
179 | 				if ($pscmdlet.ShouldProcess("$Identity", "Remove Account and any child objects"))
180 | 				{
181 | 					$Account = Get-ADSIComputer -Identity $Identity @ContextSplatting
182 | 					$Account.GetUnderlyingObject().deletetree()
183 | 				}
184 | 			}
185 | 			
186 | 		}
187 | 		CATCH
188 | 		{
189 | 			$pscmdlet.ThrowTerminatingError($_)
190 | 		}
191 | 	}
192 | }
193 | try
194 | {
195 | 	Get-NetConnectionProfile -ErrorAction Stop | Set-NetConnectionProfile -NetworkCategory private -ErrorAction Stop
196 | }
197 | catch
198 | {
199 | 	Write-host "Network adapters already set to private network type"
200 | }
201 | <% if options[:computer_name] != nil %>
202 | $computerName='<%= options[:computer_name] %>'
203 | <% else %>
204 | $computerName = $env:COMPUTERNAME
205 | <% end %>
206 | <% if options[:username] != nil && options[:unsecure] != true %>
207 | $domain='<%= options[:domain] %>'
208 | $username='<%= options[:username] %>'
209 | $password='<%= options[:password] %>'
210 | $secpasswd = ConvertTo-SecureString $password -AsPlainText -Force
211 | $credentials = New-Object System.Management.Automation.PSCredential ($username, $secpasswd)
212 | <% end %>
213 | 
214 | <% if options[:add_to_domain] === true %>
215 | if (Test-PartOfDomain -computerName $computerName -domain $domain){
216 | 	throw "$computerName already part of domain $domain"
217 | } else {
218 | 	#If a value is provided for the Primary_DNS and Secondary_DNS variable in the vagrantfile, powershell will determine if the string is a valid IP and will statically set the primary and secondary dns servers of the vm's nic if it is.  If only Primary_DNS variable is provided, powershell will statically set the primary dns server of the vm's nic while leaving the secondary unset.
219 | 	<% if options[:primary_dns] != nil %>
220 | 		$wmi = Get-WmiObject -ComputerName $env:COMPUTERNAME -Namespace "root\CIMV2" -Class "Win32_NetworkAdapterconfiguration" -Filter 'IPENABLED=TRUE AND Index=2' -Impersonation Impersonate -ErrorAction Stop | Where-Object { $_.DefaultIPGateway }
221 | 		# $currdns = $wmi.DNSServerSearchOrder
222 | 		$prim = '<%= options[:primary_dns] %>'
223 | 		# Modified the configuration so that the secondary dns can only be set if the primary dns server has also been set
224 | 		<% if options[:secondary_dns] != nil %>
225 | 			$sec = '<%= options[:secondary_dns] %>'
226 | 			If (($prim -match "^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$") -and ($sec -match "^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"))
227 | 			{
228 | 				$wmi.SetDNSServerSearchOrder(@("$prim", "$sec"))
229 | 			}
230 | 			else
231 | 			{
232 | 				throw "Invalid value provided for dns server ip"
233 | 			}
234 | 		<% else %>
235 | 			If ($prim -match "^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$")
236 | 			{
237 | 				$wmi.SetDNSServerSearchOrder("$prim")
238 | 			}
239 | 			else
240 | 			{
241 | 				throw "Invalid IP address provided"
242 | 			}
243 | 		<% end %>
244 | 	<% end %>
245 | 	Add-Computer <%= options[:parameters] %> -Verbose -Force
246 | 	# Rename computer separately: Fixes GH issue #11
247 | 	<% if options[:computer_name] != nil %>
248 | 	$completed = $false
249 | 	while ( -not $completed) {
250 | 		try {
251 | 			Rename-Computer <%= options_rename[:parameters] %> -Verbose -Force -ErrorAction Stop
252 | 			$completed = $true
253 | 		} catch {
254 | 			if ($retrycount -ge 5) {
255 | 				Write-Host ("Rename failed the maximum number of $retrycount times.")
256 | 				throw
257 | 			} else {
258 | 				Write-Host ("Rename failed, Retrying in 5 seconds...")
259 | 				Start-sleep -s 5
260 | 				$retrycount++
261 | 			}
262 | 		}
263 | 	}
264 | 	<% end %>	
265 | 	Repair-OpenSSHPasswd
266 | }
267 | <% else %>
268 | $compobj = Get-ADSIComputer -Identity $computerName -Credential $credentials -DomainName $domain
269 | if (!(Test-JoinedToADomain) -or !($compobj)) {
270 | 	# Throw "$computerName not part of any domain"
271 | 	return
272 | } else {
273 | 	#When destroying the vagrant machine, the goal is not as much to have the virtual machine disjoin from the domain, but to remove the computer object associated with the
274 | 	#machine so that future runs of vagrant up will succeed (especially when the vagrantfile explicitly defines a computer name.  That being the case, the remove-computer
275 | 	#command has been replaced with a custom function which is able to remove the computer object associated with the vagrant machine in active directory.
276 | 	try
277 | 	{
278 | 	Remove-ADSIComputer -Identity $env:COMPUTERNAME -DomainName $domain -Credential $credentials -Verbose -ErrorAction Stop
279 | 	Repair-OpenSSHPasswd
280 | 	}
281 | 	catch
282 | 	{
283 | 		Repair-OpenSSHPasswd
284 | 	}
285 | 	
286 | }
287 | <% end %>
288 | 


--------------------------------------------------------------------------------
/lib/vagrant-windows-domain/version.rb:
--------------------------------------------------------------------------------
1 | module Vagrant
2 |   module WindowsDomain
3 |     VERSION = "1.3.5"
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/spec/base.rb:
--------------------------------------------------------------------------------
 1 | shared_context "unit" do
 2 |   before(:each) do
 3 |     # State to store the list of registered plugins that we have to
 4 |     # unregister later.
 5 |     @_plugins = []
 6 | 
 7 |     # Create a thing to store our temporary files so that they aren't
 8 |     # unlinked right away.
 9 |     @_temp_files = []
10 |   end
11 | 
12 |   # This helper creates a temporary file and returns a Pathname
13 |   # object pointed to it.
14 |   #
15 |   # @return [Pathname]
16 |   def temporary_file(contents=nil)
17 |     f = Tempfile.new("vagrant-unit")
18 | 
19 |     if contents
20 |       f.write(contents)
21 |       f.flush
22 |     end
23 | 
24 |     # Store the tempfile in an instance variable so that it is not
25 |     # garbage collected, so that the tempfile is not unlinked.
26 |     @_temp_files << f
27 | 
28 |     return Pathname.new(f.path)
29 |   end
30 | 
31 |   # Asserts that the current (config) validation run should fail.
32 |   # Any error message is sufficient.
33 |   def assert_invalid
34 |     errors = subject.validate(machine)
35 |     if !errors.values.any? { |v| !v.empty? }
36 |       raise "No errors: #{errors.inspect}"
37 |     end
38 |   end
39 | 
40 |   # Asserts that the current (config) validation should fail with a specific message.
41 |   def assert_error(error)
42 |     errors = subject.validate(machine)
43 |     raise "Error #{error} was not raised" if !errors["windows domain provisioner"].include? error
44 |   end
45 | 
46 |   # Asserts that no failures should occur in the current (config) validation run.
47 |   def assert_valid
48 |     errors = subject.validate(machine)
49 |     if !errors.values.all? { |v| v.empty? }
50 |       raise "Errors: #{errors.inspect}"
51 |     end
52 |   end
53 | 
54 | end


--------------------------------------------------------------------------------
/spec/provisioner/config_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | require 'vagrant-windows-domain/provisioner'
 3 | require 'vagrant-windows-domain/config'
 4 | require 'base'
 5 | 
 6 | describe VagrantPlugins::WindowsDomain::Config do
 7 |   include_context "unit"
 8 |   let(:instance) { described_class.new }
 9 |   let(:machine) { double("machine") }
10 | 
11 |  let(:root_path)           { (Pathname.new(Dir.mktmpdir)).to_s }
12 |   let(:ui)                  { Vagrant::UI::Silent.new }
13 |   let(:machine)             { double("machine", ui: ui, id: "1234") }
14 |   let(:env)                 { double("environment", root_path: root_path, ui: ui) }
15 |   let(:vm)                  { double ("vm") }
16 |   let(:communicator)        { double ("communicator") }
17 |   let(:shell)               { double ("shell") }
18 |   let(:powershell)          { double ("powershell") }
19 |   let(:guest)               { double ("guest") }
20 |   let(:configuration_file)  { "manifests/MyWebsite.ps1" }
21 |   let(:module_path)         { ["foo/modules", "foo/modules2"] }
22 |   let(:root_config)         { VagrantPlugins::DSC::Config.new }
23 |   # subject                   { described_class.new machine, root_config }
24 | 
25 |   describe "defaults (finalize!)" do
26 | 
27 |     before do
28 |       env = double("environment", root_path: "/tmp/vagrant-windows-domain-path")
29 |       config = double("config")
30 |       machine.stub(config: config, env: env, id: "1234")
31 |     end
32 | 
33 |     before { subject.finalize! }
34 | 
35 |     its("domain")            { should be_nil }
36 |     its("computer_name")     { should eq(nil) }
37 |     its("username")          { should be_nil }
38 |     its("password")          { should be_nil }
39 |     its("join_options")      { should eq({})   }
40 |     its("ou_path")           { should be_nil }
41 |     its("unsecure")          { should eq(false) }
42 | 
43 |     it "should ignore empty strings" do
44 |       subject.domain = ""
45 |       subject.username = ""
46 |       subject.password = ""
47 |       subject.computer_name = ""
48 |       
49 |       subject.finalize!
50 | 
51 |       expect(subject.domain).to be_nil
52 |       expect(subject.computer_name).to be_nil
53 |       expect(subject.username).to be_nil
54 |       expect(subject.password).to be_nil
55 | 	  
56 |     end
57 |   end
58 | 
59 |   describe "validate settings" do
60 |     before do
61 |       env = double("environment", root_path: "/tmp/vagrant-windows-domain-path")
62 |       config = double("config")
63 |       machine.stub(config: config, env: env)
64 |       allow(machine).to receive(:communicate).and_return(communicator)
65 |       allow(communicator).to receive(:shell).and_return(shell)
66 |       allow(shell).to receive(:powershell).and_yield(:stdout, "myoldcomputername")
67 |     end
68 | 
69 |     before { subject.finalize! }
70 | 
71 |     it "should be invalid if either 'username' and 'password' or 'unsecure' are both provided" do
72 |       subject.username = "myusername"
73 |       subject.password = "mypassword"
74 |       subject.unsecure = true
75 |       subject.validate(machine)
76 | 
77 |       assert_invalid
78 |       assert_error("You must not supply a \"username\" and \"password\" if \"unsecure\" is set to true.")
79 |     end
80 |   end
81 | 
82 | end


--------------------------------------------------------------------------------
/spec/provisioner/provisioner_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | require 'vagrant-windows-domain/provisioner'
  3 | require 'vagrant-windows-domain/config'
  4 | require 'rspec/its'
  5 | 
  6 | describe VagrantPlugins::WindowsDomain::Provisioner do
  7 |   include_context "unit"
  8 | 
  9 |   let(:root_path)           { (Pathname.new(Dir.mktmpdir)).to_s }
 10 |   let(:ui)                  { double("ui") }
 11 |   let(:machine)             { double("machine", ui: ui, id: "1234") }
 12 |   let(:env)                 { double("environment", root_path: root_path, ui: ui) }
 13 |   let(:vm)                  { double ("vm") }
 14 |   let(:communicator)        { double ("communicator") }
 15 |   let(:shell)               { double ("shell") }
 16 |   let(:powershell)          { double ("powershell") }
 17 |   let(:guest)               { double ("guest") }
 18 |   let(:configuration_file)  { "manifests/MyWebsite.ps1" }
 19 |   let(:module_path)         { ["foo/modules", "foo/modules2"] }
 20 |   let(:root_config)         { VagrantPlugins::WindowsDomain::Config.new }
 21 |   subject                   { described_class.new machine, root_config }
 22 | 
 23 |   describe "configure" do
 24 |     before do
 25 |       allow(machine).to receive(:root_config).and_return(root_config)
 26 |       machine.stub(config: root_config, env: env, id: "1234")
 27 |       allow(ui).to receive(:say).with(any_args)
 28 |       allow(machine).to receive(:communicate).and_return(communicator)
 29 |       allow(communicator).to receive(:shell).and_return(shell)
 30 |       allow(shell).to receive(:powershell).with("$env:COMPUTERNAME").and_yield(:stdout, "myoldcomputername")
 31 |       allow(root_config).to receive(:vm).and_return(vm)
 32 |       allow(vm).to receive(:communicator).and_return(:winrm)
 33 |       root_config.finalize!
 34 |       root_config.validate(machine)
 35 |     end
 36 | 
 37 |     it "should confirm if the OS is Windows" do
 38 |       allow(communicator).to receive(:sudo).twice
 39 |       expect(subject.windows?).to eq(true)
 40 |       subject.configure(root_config)
 41 |     end
 42 | 
 43 |     it "should error if the detected OS is not Windows" do
 44 |       allow(vm).to receive(:communicator).and_return(:ssh)
 45 |       expect { subject.configure(root_config) }.to raise_error("Unsupported platform detected. Vagrant Windows Domain only works on Windows guest environments.")
 46 |     end
 47 | 
 48 |   end
 49 | 
 50 |   describe "provision" do
 51 | 
 52 |     before do
 53 |       allow(machine).to receive(:root_config).and_return(root_config)
 54 |       machine.stub(config: root_config, env: env, id: "1234")
 55 |       allow(ui).to receive(:say).with(any_args)
 56 |       allow(machine).to receive(:communicate).and_return(communicator)
 57 |       allow(communicator).to receive(:shell).and_return(shell)
 58 |       allow(shell).to receive(:powershell).with("$env:COMPUTERNAME").and_yield(:stdout, "myoldcomputername")
 59 |       allow(root_config).to receive(:vm).and_return(vm)
 60 |       allow(vm).to receive(:communicator).and_return(:winrm)
 61 |       allow(communicator).to receive(:sudo).with("which Add-Computer", {:error_class=>VagrantPlugins::WindowsDomain::WindowsDomainError, :error_key=>:binary_not_detected, :domain=>"foo.com", :binary=>"Add-Computer"})
 62 |       allow(communicator).to receive(:sudo).with("which Remove-Computer", {:error_class=>VagrantPlugins::WindowsDomain::WindowsDomainError, :error_key=>:binary_not_detected, :domain=>"foo.com", :binary=>"Remove-Computer"})
 63 | 
 64 |       root_config.domain = "foo.com"
 65 |       root_config.username = "username"
 66 |       root_config.password = "password"
 67 | 
 68 |       root_config.finalize!
 69 |       root_config.validate(machine)
 70 |       subject.configure(root_config)
 71 |     end
 72 | 
 73 |     it "should join the domain" do
 74 |       allow(communicator).to receive(:upload)
 75 |       allow(ui).to receive(:info)
 76 |       expect(communicator).to receive(:test)
 77 |       expect(vm).to receive(:boot_timeout).once
 78 |       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})
 79 |       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
 80 |       expect(machine).to receive(:action).with(:reload, {:provision_ignore_sentinel=>false, :lock=>false}).once
 81 |       expect(communicator).to receive(:ready?).and_return(true).once
 82 |       subject.restart_sleep_duration = 0
 83 |       subject.provision
 84 |       expect(subject.old_computer_name).to eq("myoldcomputername")
 85 |     end
 86 | 
 87 |     it "should restart the machine on a successful domain join" do
 88 |       allow(communicator).to receive(:upload)
 89 |       allow(ui).to receive(:info)
 90 |       expect(communicator).to receive(:test)
 91 |       expect(vm).to receive(:boot_timeout).once
 92 |       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})
 93 |       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
 94 |       expect(machine).to receive(:action). with(:reload, {:provision_ignore_sentinel=>false, :lock=>false}).once
 95 |       expect(communicator).to receive(:ready?).and_return(true).once
 96 |       subject.restart_sleep_duration = 0
 97 |       subject.provision
 98 |     end
 99 | 
100 |     it "should not restart the machine on a failed domain join attempt" do
101 |       allow(communicator).to receive(:upload)
102 |       expect(communicator).to receive(:test)
103 |       expect(vm).to_not receive(:boot_timeout)
104 |       allow(ui).to receive(:info).with("some exception thrown!", {:color=>:red, :new_line=>false, :prefix=>false}) # Red output on error please!
105 |       allow(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
106 |       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!")
107 |       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
108 |       expect(machine).to_not receive(:action). with(:reload, {:provision_ignore_sentinel=>false, :lock=>false})
109 |       subject.restart_sleep_duration = 0
110 |       subject.provision
111 |     end
112 | 
113 |     context "generate_command_arguments" do
114 | 
115 |       it "join with credentials if provided" do
116 |         args = subject.generate_command_arguments
117 |       end
118 | 
119 |       it "not join with credentials if 'unsecure' option provided" do
120 | 
121 |       end
122 | 
123 |       it "remove with credentials if provided" do
124 | 
125 |       end
126 | 
127 |       it "remove join with credentials if 'unsecure' option provided" do
128 | 
129 |       end
130 | 
131 |       it "should rename the computer if the computer name is different" do
132 | 
133 |       end
134 |       
135 |     end
136 | 
137 |     it "should prompt for credentials if not provided" do
138 |       root_config.username = nil
139 |       root_config.password = nil
140 |       expect(ui).to receive(:ask).with("Please enter your domain password (output will be hidden): ", {:echo=>false}).and_return("myusername")
141 |       expect(ui).to receive(:ask).with("Please enter your domain username: ")
142 |       subject.set_credentials
143 |     end
144 | 
145 |     it "should not prompt for credentials if provided" do
146 |       expect(ui).to_not receive(:ask)
147 |       subject.set_credentials
148 |     end
149 | 
150 |     it "should remove any traces of credentials once provisioning has occurred" do
151 |       expect(communicator).to receive(:sudo).with("del c:/tmp/vagrant-windows-domain-runner.ps1")
152 |       subject.remove_command_runner_script
153 |     end
154 | 
155 |   end
156 | 
157 |   describe "cleanup" do
158 |     before do
159 |       allow(machine).to receive(:root_config).and_return(root_config)
160 |       machine.stub(config: root_config, env: env, id: "1234")
161 |       allow(ui).to receive(:say).with(any_args)
162 |       allow(machine).to receive(:communicate).and_return(communicator)
163 |       allow(communicator).to receive(:shell).and_return(shell)
164 |       allow(shell).to receive(:powershell).with("$env:COMPUTERNAME").and_yield(:stdout, "myoldcomputername")
165 |       allow(root_config).to receive(:vm).and_return(vm)
166 |       allow(vm).to receive(:communicator).and_return(:winrm)
167 |       allow(communicator).to receive(:sudo).with("which Add-Computer", {:error_class=>VagrantPlugins::WindowsDomain::WindowsDomainError, :error_key=>:binary_not_detected, :domain=>"foo.com", :binary=>"Add-Computer"})
168 |       allow(communicator).to receive(:sudo).with("which Remove-Computer", {:error_class=>VagrantPlugins::WindowsDomain::WindowsDomainError, :error_key=>:binary_not_detected, :domain=>"foo.com", :binary=>"Remove-Computer"})
169 | 
170 |       root_config.domain = "foo.com"
171 |       root_config.username = "username"
172 |       root_config.password = "password"
173 | 
174 |       root_config.finalize!
175 |       root_config.validate(machine)
176 |       subject.configure(root_config)
177 |     end
178 | 
179 |     it "should leave domain" do
180 |       allow(machine).to receive(:communicate).and_return(communicator)
181 |       expect(communicator).to receive(:upload)
182 |       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")
183 |       expect(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
184 |       expect(ui).to receive(:info).with("deleted", {:color=>:green, :new_line=>false, :prefix=>false})
185 |       
186 |       result = subject.leave_domain
187 |       expect(result).to eq(true)
188 |     end
189 | 
190 |     it "should leave domain when a `vagrant destroy` is issued" do
191 |       allow(machine).to receive(:communicate).and_return(communicator)
192 |       expect(communicator).to receive(:test).and_return(true)
193 |       expect(communicator).to receive(:upload)
194 |       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")
195 |       expect(ui).to receive(:info).with("\"Running Windows Domain Provisioner\"")
196 |       expect(ui).to receive(:info).with("deleted", {:color=>:green, :new_line=>false, :prefix=>false})
197 | 
198 |       subject.cleanup
199 |     end
200 | 
201 |     it "should not leave domain plugin not associated with current Vagrantfile" do
202 |       allow(machine).to receive(:communicate).and_return(communicator)
203 | 
204 |       subject = described_class.new machine, double("env", :domain => nil)
205 | 
206 |       expect(ui).to_not receive(:ask)
207 |       expect(subject.cleanup).to eq(nil)
208 |     end
209 | 
210 |     it "should ask for credentials when leaving domain when no credentials were provided" do
211 |       root_config.username = nil
212 |       root_config.password = nil
213 |       allow(machine).to receive(:communicate).and_return(communicator)
214 |       allow(machine).to receive(:env).and_return(env)
215 | 
216 |       expect(communicator).to receive(:test).and_return(true)
217 |       expect(communicator).to receive(:upload)
218 |       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")
219 |       expect(ui).to receive(:info).with(any_args).twice
220 |       expect(ui).to receive(:ask).with("Please enter your domain password (output will be hidden): ", {:echo=>false}).and_return("myusername")
221 |       expect(ui).to receive(:ask).with("Please enter your domain username: ")
222 |       subject.cleanup
223 |     end
224 | 
225 |   end
226 | end
227 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'simplecov'
 2 | require 'coveralls'
 3 | 
 4 | require 'vagrant-windows-domain/version'
 5 | require 'vagrant-windows-domain/plugin'
 6 | require 'rspec/its'
 7 | require 'base'
 8 | 
 9 | SimpleCov.formatters = [
10 |     SimpleCov::Formatter::HTMLFormatter,
11 |     Coveralls::SimpleCov::Formatter
12 | ]
13 | 
14 | SimpleCov.start do
15 |   coverage_dir('tmp/coverage')
16 |   add_filter '/spec/'
17 | end
18 | 
19 | RSpec.configure do |config|
20 |   config.expect_with :rspec do |c|
21 |     c.syntax = [:should, :expect]
22 |   end
23 |   config.color = true
24 |   config.tty = true
25 | end


--------------------------------------------------------------------------------
/vagrant-windows-domain.gemspec:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | lib = File.expand_path('../lib', __FILE__)
 3 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 4 | require 'vagrant-windows-domain/version'
 5 | 
 6 | Gem::Specification.new do |spec|
 7 |   spec.name          = "vagrant-windows-domain"
 8 |   spec.version       = Vagrant::WindowsDomain::VERSION
 9 |   spec.authors       = ["Matt Fellows"]
10 |   spec.email         = ["matt.fellows@onegeek.com.au"]
11 |   spec.summary       = "Windows Domain Provisioner for Vagrant"
12 |   spec.description   = "Adds and Removes Windows Guests from a Windows Domain, as part of the standard machine lifecycle."
13 |   spec.homepage      = "https://github.com/mefellows/vagrant-windows-domain"
14 |   spec.license       = "MIT"
15 | 
16 |   spec.files         = `git ls-files -z`.split("\x0")
17 |   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
18 |   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
19 |   spec.require_paths = ["lib"]
20 | 
21 |   spec.add_development_dependency "rake"
22 |   spec.add_development_dependency "bundler"
23 |   spec.add_development_dependency "coveralls"
24 |   spec.add_development_dependency "rspec-core"
25 |   spec.add_development_dependency "rspec-expectations"
26 |   spec.add_development_dependency "rspec-mocks"
27 |   spec.add_development_dependency "rspec-its"
28 | end
29 | 


--------------------------------------------------------------------------------