├── lib
    ├── vagrant-dsc
    │   ├── version.rb
    │   ├── powershell
    │   │   └── configure_dsc.ps1
    │   ├── plugin.rb
    │   ├── locales
    │   │   └── en.yml
    │   ├── templates
    │   │   └── runner.ps1.erb
    │   ├── config.rb
    │   └── provisioner.rb
    └── vagrant-dsc.rb
├── development
    ├── web
    │   ├── website
    │   │   └── index.html
    │   ├── modules
    │   │   └── MyWebapp
    │   │   │   ├── MyWebapp.psd1
    │   │   │   └── DSCResources
    │   │   │       └── SimpleWebsite
    │   │   │           ├── SimpleWebsite.psd1
    │   │   │           └── SimpleWebsite.schema.psm1
    │   ├── manifests
    │   │   ├── MyConfig.psd1
    │   │   └── MyWebsite.ps1
    │   └── Vagrantfile
    └── reboot
    │   ├── manifests
    │       ├── LCMConfig.ps1
    │       └── Reboot.ps1
    │   └── Vagrantfile
├── appveyor.yml
├── Gemfile
├── .gitignore
├── .vscode
    └── launch.json
├── Rakefile
├── .travis.yml
├── spec
    ├── spec_helper.rb
    ├── base.rb
    └── provisioner
    │   ├── config_spec.rb
    │   └── provisioner_spec.rb
├── LICENSE.txt
├── vagrant-dsc.gemspec
└── README.md


/lib/vagrant-dsc/version.rb:
--------------------------------------------------------------------------------
1 | module Vagrant
2 |   module Dsc
3 |     VERSION = "2.0.0"
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/development/web/website/index.html:
--------------------------------------------------------------------------------
1 | <h1>Hello from Vagrant DSC!</h1>
2 | <img src="http://www.drodd.com/images10/funny-cat-gifs17.gif" />
3 | 


--------------------------------------------------------------------------------
/development/web/modules/MyWebapp/MyWebapp.psd1:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mefellows/vagrant-dsc/HEAD/development/web/modules/MyWebapp/MyWebapp.psd1


--------------------------------------------------------------------------------
/development/web/modules/MyWebapp/DSCResources/SimpleWebsite/SimpleWebsite.psd1:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mefellows/vagrant-dsc/HEAD/development/web/modules/MyWebapp/DSCResources/SimpleWebsite/SimpleWebsite.psd1


--------------------------------------------------------------------------------
/development/web/manifests/MyConfig.psd1:
--------------------------------------------------------------------------------
 1 | @{   
 2 |     AllNodes =
 3 |     @(
 4 |         @{     
 5 |           NodeName = "localhost"; 
 6 |           PSDscAllowPlainTextPassword = $true; 
 7 |           RebootIfNeeded = $True;
 8 |         }
 9 |     )
10 | } 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | install:
 2 |   - set PATH=C:\Ruby22\bin;%PATH%
 3 |   - gem install bundler -v 1.12.5
 4 |   - bundle _1.12.5_ install  
 5 | 
 6 | build: off
 7 | 
 8 | before_test:
 9 |   - ruby -v
10 |   - gem -v
11 |   - bundle -v
12 | 
13 | test_script:
14 |   - bundle _1.12.5_ exec rake spec
15 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | source 'https://rubygems.org'
 2 | 
 3 | # Specify your gem's dependencies in vagrant-dsc.gemspec
 4 | gemspec
 5 | 
 6 | group :development do
 7 |   gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
 8 | end
 9 | 
10 | group :plugins do
11 |   gem "vagrant-dsc", path: "."
12 | end


--------------------------------------------------------------------------------
/development/reboot/manifests/LCMConfig.ps1:
--------------------------------------------------------------------------------
 1 | [DSCLocalConfigurationManager()]
 2 | configuration LCMConfig
 3 | {
 4 |     Node localhost
 5 |     {
 6 |         Settings
 7 |         {
 8 |             RebootNodeIfNeeded = $true
 9 |             ActionAfterReboot = "ContinueConfiguration"
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/.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
25 | bin/


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "version": "0.2.0",
 3 |     "configurations": [
 4 |         {
 5 |             "name": "Launch Tests",
 6 |             "type": "Ruby",
 7 |             "request": "launch",
 8 |             "cwd": "${workspaceRoot}",
 9 |             "program": "${workspaceRoot}/bin/rake",
10 |             "args": [
11 |                 "spec"
12 |             ]
13 |         }
14 |     ]
15 | }


--------------------------------------------------------------------------------
/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


--------------------------------------------------------------------------------
/lib/vagrant-dsc/powershell/configure_dsc.ps1:
--------------------------------------------------------------------------------
 1 | # Sets up DSC
 2 | echo 'Setting up DSC components'
 3 | 
 4 | $ChocoInstallPathOld = "$env:SystemDrive\Chocolatey\bin"
 5 | $ChocoInstallPath = "$env:SystemDrive\ProgramData\Chocolatey\bin"
 6 | 
 7 | # Install chocolatey
 8 | if ( !(Get-Command "choco") -and !(Test-Path $ChocoInstallPath)) {
 9 |   iex ((new-object net.webclient).DownloadString('http://chocolatey.org/install.ps1'))
10 | }
11 | 
12 | choco install DotNet4.5
13 | choco install powershell4


--------------------------------------------------------------------------------
/lib/vagrant-dsc.rb:
--------------------------------------------------------------------------------
 1 | require "pathname"
 2 | 
 3 | require "vagrant-dsc/plugin"
 4 | 
 5 | module VagrantPlugins
 6 |   module DSC
 7 |     lib_path = Pathname.new(File.expand_path("../vagrant-dsc", __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-dsc/plugin.rb:
--------------------------------------------------------------------------------
 1 | require "vagrant"
 2 | 
 3 | module VagrantPlugins
 4 |   module DSC
 5 |     class Plugin < Vagrant.plugin("2")
 6 |       name "DSC"
 7 |       description <<-DESC
 8 |         Provides support for provisioning your virtual machines with
 9 |         DSC either using a local `DSC` Configuration or a DSC server.
10 |       DESC
11 | 
12 |       config(:dsc, :provisioner) do
13 |         require_relative 'config'
14 |         Config
15 |       end
16 | 
17 |       provisioner(:dsc) do
18 |         require_relative 'provisioner'
19 |         Provisioner
20 |       end
21 |     end
22 |   end
23 | end


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: ruby
 2 | before_install:
 3 | - rvm @global do gem uninstall bundler --all --executables
 4 | - gem uninstall bundler --all --executables
 5 | - gem install bundler --version '1.12.5'
 6 | rvm:
 7 | - 2.2.3
 8 | - ruby-head
 9 | matrix:
10 |   allow_failures:
11 |   - rvm: ruby-head
12 |   fast_finish: true
13 | env:
14 |   matrix:
15 |   - VAGRANT_VERSION=v1.8.5
16 |   global:
17 |     secure: d34dSoYsh9C9tCgAeKp3TIYdxPlrGh1j+x01Igg7Ku0rmmv0f1+NSZOcSpgbf5daXFk1i5mQrRcYjIVOclGAlCXM7IKWfDyefstmYl+2+Hjv4LGJHQNvBTz02MerfKlUef2HMAt3HJsNvwhqvIVrHetC6ZeSaFtupWqhuXWgREQ=
18 | script: bundle exec rake test:unit
19 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'simplecov'
 2 | require 'coveralls'
 3 | 
 4 | require 'vagrant-dsc/version'
 5 | require 'vagrant-dsc/plugin'
 6 | require 'rspec/its'
 7 | require 'base'
 8 | 
 9 | SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
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 = :expect
22 |   end
23 |   config.color = true
24 |   config.tty = true
25 |   # config.raise_errors_for_deprecations!
26 | end


--------------------------------------------------------------------------------
/development/reboot/manifests/Reboot.ps1:
--------------------------------------------------------------------------------
 1 | Configuration Reboot
 2 | {
 3 |     Import-DscResource -ModuleName 'PSDesiredStateConfiguration'
 4 |     
 5 |     Script Reboot
 6 |     {
 7 |         TestScript = {
 8 |             return (Test-Path HKLM:\SOFTWARE\MyMainKey\RebootKey)
 9 |         }
10 |         SetScript = {
11 |             New-Item -Path HKLM:\SOFTWARE\MyMainKey\RebootKey -Force
12 |                 $global:DSCMachineStatus = 1 
13 | 
14 |         }
15 |         GetScript = { return @{result = 'result'}}
16 |     }
17 | 
18 |     Script Error
19 |     {
20 |         TestScript = {
21 |             throw "This did not work"
22 |             return $true
23 |         }
24 |         SetScript = { 
25 | 
26 |         }
27 |         GetScript = { return @{result = 'result'}}
28 |         DependsOn = "[Script]Reboot"
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/development/web/manifests/MyWebsite.ps1:
--------------------------------------------------------------------------------
 1 | Configuration MyWebsite
 2 | {
 3 |   param ($MachineName, $HostName)
 4 | 
 5 |   Import-DscResource -Module MyWebapp
 6 |   Import-DscResource -Module cNetworking
 7 | 
 8 |   Node $MachineName
 9 |   {
10 |     WindowsFeature IIS
11 |     {
12 |         Ensure = "Present"
13 |         Name = "Web-Server"
14 |     }
15 | 
16 |     WindowsFeature IISManagerFeature
17 |     {
18 |         Ensure = "Present"
19 |         Name = "Web-Mgmt-Tools"
20 |     }
21 | 
22 |     cFirewallRule webFirewall
23 |     {
24 |         Name = "WebFirewallOpen"
25 |         Direction = "Inbound"
26 |         LocalPort = "80"
27 |         Protocol = "TCP"
28 |         Action = "Allow"
29 |         Ensure = "Present"
30 |     }
31 | 
32 |     SimpleWebsite sWebsite
33 |     {
34 |         WebAppPath = "c:\MyWebApp"
35 |         DependsOn  = '[cWebsite]DefaultWebsite'
36 |         HostName = $HostName
37 |     }
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/development/reboot/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | $shell_script = <<SCRIPT
 5 |   # config desired state
 6 |   . C:\\vagrant\\manifests\\LCMConfig.ps1
 7 |   LCMConfig
 8 |   Set-DscLocalConfigurationManager -Path ".\\LCMConfig"
 9 | SCRIPT
10 | 
11 | VAGRANTFILE_API_VERSION = "2"
12 | 
13 | # linked clone feature requires 1.8
14 | Vagrant.require_version ">= 1.8" 
15 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
16 |   config.vm.box = "mwrock/Windows2016"
17 |   config.vm.guest = :windows
18 |   config.vm.communicator = "winrm"
19 | 
20 |   # we do not need, the following config, but gives some convenience
21 |   config.vm.provider "virtualbox" do |v|
22 |     # Link clone, get a faster up after destroy
23 |     v.linked_clone = true
24 |     # Get the clipboard to interact with host
25 |     v.customize ["modifyvm", :id, "--clipboard", "bidirectional"]
26 |   end
27 | 
28 |   config.vm.provision "shell", inline: $shell_script
29 | 
30 |   config.vm.provision "dsc" do |dsc|
31 |     dsc.configuration_file  = "Reboot.ps1"
32 |     dsc.configuration_name = "Reboot"
33 |     dsc.manifests_path = "manifests"      
34 |   end
35 | end
36 | 


--------------------------------------------------------------------------------
/vagrant-dsc.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-dsc/version'
 5 | 
 6 | Gem::Specification.new do |spec|
 7 |   spec.name          = "vagrant-dsc"
 8 |   spec.version       = Vagrant::Dsc::VERSION
 9 |   spec.authors       = ["Matt Fellows"]
10 |   spec.email         = ["matt.fellows@onegeek.com.au"]
11 |   spec.summary       = "DSC Provisioner for Vagrant"
12 |   spec.description   = "Desired State Configuration (http://technet.microsoft.com/en-au/library/dn249912.aspx) provisioning plugin for Vagrant."
13 |   spec.homepage      = "https://github.com/mefellows/vagrant-dsc"
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"#, '~> 10.3', '>= 10.3.0'
22 |   spec.add_development_dependency "coveralls"#, "~> 0.7.1", '>= 0.7.1'
23 |   spec.add_development_dependency "rspec-core"#, '~> 3.1', '>= 3.1.0'
24 |   spec.add_development_dependency "rspec-expectations"#, '~> 3.1', '>= 3.1.0'
25 |   spec.add_development_dependency "rspec-mocks" #, '~> 3.1', '>= 3.1.0'
26 |   spec.add_development_dependency "rspec-its" #, "~> 1.0.1", '>= 1.0.0'
27 | end
28 | 


--------------------------------------------------------------------------------
/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["dsc provisioner"].any? { |val| error =~ val }
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


--------------------------------------------------------------------------------
/development/web/modules/MyWebapp/DSCResources/SimpleWebsite/SimpleWebsite.schema.psm1:
--------------------------------------------------------------------------------
 1 | Configuration SimpleWebsite
 2 | {
 3 |     param
 4 |     (
 5 |         [String]$WebAppPath             = "c:\myWebApp",
 6 |         [String]$WebSiteName            = "MyWebApp",
 7 |         [String]$HostNameSuffix         = "local",
 8 |         [String]$HostName               = "vagrantdsc.${HostNameSuffix}",
 9 |         [String]$ApiAppPoolName         = "MyWebAppPool",
10 |         [HashTable]$AuthenticationInfo = @{Anonymous = "true"; Basic = "false"; Digest = "false"; Windows = "false"}
11 |     )
12 | 
13 |     Import-DscResource -Module cWebAdministration
14 |     Import-DscResource -Module cNetworking
15 | 
16 |     # Stop the default website
17 |     cWebsite DefaultSite
18 |     {
19 |         Ensure          = "Absent"
20 |         Name            = "Default Web Site"
21 |         State           = "Stopped"
22 |         PhysicalPath    = "C:\inetpub\wwwroot"
23 |     }
24 | 
25 |     cWebsite UrlSvcWebsite
26 |     {
27 |         Ensure = "Present"
28 |         Name   = $WebSiteName
29 |         BindingInfo = @(SEEK_cWebBindingInformation
30 |         {
31 |             Protocol = "http"
32 |             Port = 80
33 |             IPAddress = "*"
34 |         })
35 |         AuthenticationInfo = SEEK_cWebAuthenticationInformation { Anonymous = "true" }
36 |         HostFileInfo = @(SEEK_cHostEntryFileInformation
37 |         {
38 |             RequireHostFileEntry = $True
39 |             HostEntryName = $HostName
40 |             HostIpAddress = "10.0.0.30"
41 |         })
42 |         PhysicalPath = $WebAppPath
43 |         State = "Started"
44 |         DependsOn = @("[cWebsite]DefaultSite")
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/lib/vagrant-dsc/locales/en.yml:
--------------------------------------------------------------------------------
 1 | en:
 2 |   vagrant_dsc:
 3 |     already_status: |-
 4 |       The machine is already %{status}.
 5 | 
 6 |     running_dsc: |-
 7 |       "Running DSC Provisioner with %{manifest}..."
 8 | 
 9 |     will_not_destroy: |-
10 |       The instance '%{name}' will not be destroyed, since the confirmation
11 |       was declined.
12 | 
13 |     config:
14 |       access_key_id_required: |-
15 |         An access key ID must be specified via "access_key_id"
16 | 
17 |     errors:
18 |       missing_shared_folders: |-
19 |         Shared folders not properly configured. This is generally resolved by a 'vagrant halt && vagrant up'
20 |       unsupported_os: |-
21 |         Vagrant DSC does not work
22 |       dsc_not_detected: |-
23 |         Unable to detect a working DSC environment. Please ensure powershell v4+
24 |         is installed, including WMF 4+.
25 |       dsc_incorrect_powershell_version: |-
26 |         Powershell version 4 or greater not installed. Please ensure powershell v4+ is installed, including WMF 4+.
27 |       module_path_missing: |-
28 |         "Path to DSC Modules does not exist: %{path}"
29 |       manifests_path_missing: |-
30 |         "Path to DSC Manifest folder does not exist: %{path}"
31 |       manifest_missing: |-
32 |         "Path to DSC Manifest does not exist: %{manifest}"
33 |       configuration_data_missing: |-
34 |         "Path to DSC Configuration Data file does not exist: %{path}"
35 |       manifest_and_mof_provided: |-
36 |         "Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two."
37 |       unsupported_operation: |-
38 |         "Operation unsupported / not-yet implemented: %{operation}"
39 |       absolute_module_path: |-
40 |         "Absolute 'module_path' not allowed. Please provide a path relative to your Vagrantfile."
41 |       failure_status: |-
42 |         "DSC Status is 'Failure'."
43 |       winrm_authorization_error_recover: |-
44 |         The host terminated the active connection. Try to wait for the completion of DSC.
45 |       dsc_configuration_failed: |-
46 |         Executing the DSC failed. Set 'abort_on_dsc_failure' to false to ignore DSC errors.
47 | 


--------------------------------------------------------------------------------
/lib/vagrant-dsc/templates/runner.ps1.erb:
--------------------------------------------------------------------------------
 1 | #
 2 | # DSC Runner.
 3 | #
 4 | # Bootstraps the DSC environment, sets up configuration data
 5 | # and runs the DSC Configuration.
 6 | #
 7 | #
 8 | 
 9 | # Set the local PowerShell Module environment path
10 | <% if !options[:module_paths].empty?  %>
11 | $absoluteModulePaths = [string]::Join(";", ("<%= options[:module_paths] %>".Split(";") | ForEach-Object { $_ | Resolve-Path }))
12 | 
13 | echo "Adding to path: $absoluteModulePaths"
14 | $env:PSModulePath="$absoluteModulePaths;${env:PSModulePath}"
15 | ("<%= options[:module_paths] %>".Split(";") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
16 | <% end %>
17 | 
18 | <% if !options[:module_install].empty?  %>
19 | Write-Host "Ensure Modules"
20 | Get-PackageProvider -Name NuGet -ListAvailable -ErrorAction SilentlyContinue -ErrorVariable NuGetError | Out-Null
21 | if ($NuGetError) {
22 |     Write-Host "Install Package Provider Nuget"
23 |     Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force | Out-Null
24 | }
25 | if ((Get-PSRepository -Name PSGallery).InstallationPolicy -ne "Trusted") {
26 |     Set-PSRepository -Name PSGallery -InstallationPolicy "Trusted"
27 | }
28 | # Install-Module only installs if the module is not already installed
29 | "<%= options[:module_install] %>".Split(";") | foreach { Install-Module $_ }
30 | <% end %>
31 | 
32 | $script = $(Join-Path "<%= options[:temp_path] %>" "<%= options[:configuration_file_path] %>" -Resolve)
33 | echo "PSModulePath Configured: ${env:PSModulePath}"
34 | echo ""
35 | echo "Running Configuration file: ${script}"
36 | 
37 | # Generate the MOF file, only if a MOF path not already provided.
38 | <% if options[:mof_path] == nil %>
39 | # Import the Manifest
40 | . $script
41 | 
42 | cd "<%= options[:temp_path] %>"
43 | $StagingPath = $(Join-Path "<%= options[:temp_path] %>" "staging")
44 | <% if options[:configuration_data_file_path] != nil %>
45 | $Config = $(iex (Get-Content (Join-Path "<%= options[:temp_path] %>" "<%= options[:configuration_data_file_path] %>" -Resolve) | Out-String))
46 | <% end %>
47 | <%=options[:configuration_name]%> -OutputPath $StagingPath <%= options[:parameters] %><% if options[:configuration_data_file_path] != nil %> -ConfigurationData $Config<% end %>
48 | <% else %> 
49 | $StagingPath = "<%= options[:mof_path] %>"
50 | <% end %>
51 | 
52 | # Start a DSC Configuration run
53 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
54 | del $StagingPath\*.mof
55 | 


--------------------------------------------------------------------------------
/development/web/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | $shell_script = <<SCRIPT
 5 |   choco install seek-dsc -y
 6 |   Install-WindowsFeature Web-Server
 7 |   Get-DSCResource
 8 | SCRIPT
 9 | 
10 | # Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
11 | VAGRANTFILE_API_VERSION = "2"
12 | 
13 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
14 |   # All Vagrant configuration is done here. The most common configuration
15 |   # options are documented and commented below. For a complete reference,
16 |   # please see the online documentation at vagrantup.com.
17 | 
18 |   # Every Vagrant virtual environment requires a box to build off of.
19 |   config.vm.box = "mfellows/windows2012r2"
20 |   config.vm.box_version = "1.0.1"
21 | 
22 | 
23 |   hostname = "vagrantdsc.local"
24 |   ip_address = "10.0.0.30"
25 |   config.vm.guest = :windows
26 |   config.vm.communicator = "winrm"
27 |   config.vm.network :forwarded_port, guest: 5985, host: 5985, id: "winrm", auto_correct: true
28 |   config.vm.network :forwarded_port, guest: 80,   host: 8000, id: "web" # Port forward for IIS
29 |   config.vm.network :forwarded_port, guest: 443, host: 8443,  id: "ssl" # Port forward for SSL IIS
30 |   config.vm.network :forwarded_port, guest: 22, host: 9222,  id: "ssh" # Port forward for SSL IIS
31 |   config.vm.network "private_network", ip: ip_address
32 | 
33 |   if Vagrant.has_plugin?("vagrant-multi-hostsupdater")
34 |     config.multihostsupdater.aliases = {ip_address => [hostname]}
35 |   end
36 | 
37 |   config.vm.provider "virtualbox" do |v|
38 |     v.gui = true
39 |   end
40 | 
41 |   # Install Chocolatey and some basic DSC Resources
42 |   config.vm.provision "shell", inline: $shell_script
43 | 
44 |   # Upload Website
45 |   config.vm.provision "file", source: "website", destination: "c:\\MyWebApp"
46 | 
47 |   # Run DSC
48 |   config.vm.provision "dsc" do |dsc|
49 | 
50 |     # Set of module paths relative to the Vagrantfile dir.
51 |     #
52 |     # These paths are added to the DSC Configuration running
53 |     # environment to enable local modules to be addressed.
54 |     #
55 |     # @return [Array] Set of relative module paths.
56 |     dsc.module_path = ["modules"]
57 | 
58 |     # The path relative to `dsc.manifests_path` pointing to the Configuration file
59 |     dsc.configuration_file  = "MyWebsite.ps1"
60 | 
61 |     # The path relative to Vagrantfile pointing to the Configuration Data file
62 |     dsc.configuration_data_file  = "manifests/MyConfig.psd1"
63 | 
64 |     # The Configuration Command to run. Assumed to be the same as the `dsc.configuration_file`
65 |     # (sans extension) if not provided.
66 |     dsc.configuration_name = "MyWebsite"
67 | 
68 |     # Relative path to a pre-generated MOF file.
69 |     #
70 |     # Path is relative to the folder containing the Vagrantfile.
71 |     # dsc.mof_path = "mof"
72 | 
73 |     # Relative path to the folder containing the root Configuration manifest file.
74 |     # Defaults to 'manifests'.
75 |     #
76 |     # Path is relative to the folder containing the Vagrantfile.
77 |     dsc.manifests_path = "manifests"
78 | 
79 |     # Commandline arguments to the Configuration run
80 |     #
81 |     # Set of Parameters to pass to the DSC Configuration.
82 |     dsc.configuration_params = {"-MachineName" => "localhost", "-HostName" => "#{hostname}"}
83 | 
84 |     # The type of synced folders to use when sharing the data
85 |     # required for the provisioner to work properly.
86 |     #
87 |     # By default this will use the default synced folder type.
88 |     # For example, you can set this to "nfs" to use NFS synced folders.
89 |     # dsc.synced_folder_type = ""
90 | 
91 |     # Temporary working directory on the guest machine.
92 |     # dsc.temp_dir = "c:/tmp/vagrant-dsc"
93 |   end
94 | end
95 | 


--------------------------------------------------------------------------------
/spec/provisioner/config_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | require 'vagrant-dsc/provisioner'
  3 | require 'vagrant-dsc/config'
  4 | require 'base'
  5 | 
  6 | describe VagrantPlugins::DSC::Config do
  7 |   include_context "unit"
  8 |   let(:instance) { described_class.new }
  9 |   let(:machine) { double("machine") }
 10 | 
 11 |   def valid_defaults
 12 |     # subject.prop = value
 13 |   end
 14 | 
 15 |   describe "defaults" do
 16 | 
 17 |     before do
 18 |       env = double("environment", root_path: "/tmp/vagrant-dsc-path")
 19 |       config = double("config")
 20 |       allow(machine).to receive_messages(config: config, env: env)
 21 | 
 22 |       allow(machine).to receive(:root_path).and_return("/c/foo")
 23 |     end
 24 | 
 25 |     # before do
 26 |     #   # By default lets be Linux for validations
 27 |     #   Vagrant::Util::Platform.stub(linux: true)
 28 |     # end
 29 | 
 30 |     before { subject.finalize! }
 31 | 
 32 |     its("configuration_file")             { expect = "default.ps1" }
 33 |     its("configuration_data_file")        { expect be_nil }
 34 |     its("manifests_path")                 { expect = "." }
 35 |     its("configuration_name")             { expect = "default" }
 36 |     its("mof_path")                       { expect be_nil }
 37 |     its("module_path")                    { expect be_nil }
 38 |     its("options")                        { expect = [] }
 39 |     its("configuration_params")           { expect = {} }
 40 |     its("synced_folder_type")             { expect be_nil }
 41 |     its("temp_dir")                       { expect match /^\/tmp\/vagrant-dsc-*/ }
 42 |     its("working_directory")              { expect be_nil }
 43 |     its("abort_on_dsc_failure") { expect be_false }
 44 |   end
 45 | 
 46 |   describe "derived settings" do
 47 | 
 48 |     it "should derive 'configuration_name' from 'configuration_file' automatically" do
 49 |       subject.configuration_file = "manifests/MyWebsite.ps1"
 50 |       subject.finalize!
 51 |       expect(subject.configuration_name).to eq("MyWebsite")
 52 |     end
 53 | 
 54 |     it "should derive 'configuration_name' from 'configuration_file' automatically, when given multi-level file path" do
 55 |       subject.configuration_file = "manifests/foo/MyWebsite.ps1"
 56 |       subject.finalize!
 57 |       expect(subject.configuration_name).to eq("MyWebsite")
 58 |     end
 59 | 
 60 |     it "should derive 'configuration_name' from 'configuration_file' automatically, when given no multi-level file path" do
 61 |       subject.configuration_file = "MyWebsite.ps1"
 62 |       subject.finalize!
 63 |       expect(subject.configuration_name).to eq("MyWebsite")
 64 |     end
 65 | 
 66 |     it "should detect the fully qualified path to the manifest automatically" do
 67 |       env = double("environment", root_path: "")
 68 |       config = double("config")
 69 |       allow(machine).to receive_messages(config: config, env: env)
 70 |       allow(machine).to receive(:root_path).and_return(".")
 71 | 
 72 |       subject.configuration_file = "manifests/MyWebsite.ps1"
 73 | 
 74 |       subject.finalize!
 75 |       subject.validate(machine)
 76 | 
 77 |       expect(subject.expanded_configuration_file.to_s).to match(/(C:)?#{subject.temp_dir}\/manifests\/MyWebsite.ps1$/)
 78 |     end
 79 |   end
 80 | 
 81 |   describe "validate" do
 82 |     before { subject.finalize! }
 83 | 
 84 |     before do
 85 |       env = double("environment", root_path: "")
 86 |       config = double("config")
 87 |       allow(machine).to receive_messages(config: config, env: env)
 88 | 
 89 |       allow(machine).to receive(:root_path).and_return("/path/to/vagrant")
 90 |     end
 91 | 
 92 |     # before do
 93 |     #   # By default lets be Linux for validations
 94 |     #   Vagrant::Util::Platform.stub(linux: true)
 95 |     # end
 96 | 
 97 |     # it "should disallow absolute module paths" do
 98 |     # end
 99 | 
100 |     it "should generate a module path on the host machine relative to the Vagrantfile" do
101 |       subject.module_path = "foo/modules"
102 |       expect(subject.expanded_module_paths('/path/to/vagrant/').length).to eq(1)
103 |       expect(subject.expanded_module_paths('/path/to/vagrant/')[0]).to match(/([Cc]:)?\/path\/to\/vagrant\/foo\/modules/)
104 |     end
105 | 
106 |     it "should generate a module path on the host machine relative to the Vagrantfile with relative paths" do
107 |       subject.module_path = "../modules"
108 |       expect(subject.expanded_module_paths('/path/to/vagrant/').length).to eq(1)
109 |       expect(subject.expanded_module_paths('/path/to/vagrant/')[0]).to match(/([Cc]:)?\/path\/to\/modules/)
110 |     end
111 | 
112 |     it "should generate module paths on the host machine relative to the Vagrantfile" do
113 |       subject.module_path = ["dont/exist", "also/dont/exist"]
114 |       expect(subject.expanded_module_paths('/path/to/vagrant/').length).to eq(2)
115 |       expect(subject.expanded_module_paths('/path/to/vagrant/')[0]).to match(/([Cc]:)?\/path\/to\/vagrant\/dont\/exist/)
116 |       expect(subject.expanded_module_paths('/path/to/vagrant/')[1]).to match(/([Cc]:)?\/path\/to\/vagrant\/also\/dont\/exist/)
117 |     end
118 | 
119 |     it "should be invalid if 'manifests_path' is not a real directory" do
120 |       subject.manifests_path = "/i/do/not/exist"
121 |       assert_invalid
122 |       assert_error(/\"Path to DSC Manifest folder does not exist: ([Cc]:)?\/i\/do\/not\/exist\"/)
123 |     end
124 | 
125 |     it "should be invalid if 'configuration_file' is not a real file" do
126 |       subject.manifests_path = "/"
127 |       subject.configuration_file = "notexist.ps1"
128 |       assert_invalid
129 |       assert_error(/\"Path to DSC Manifest does not exist: ([Cc]:)?\/notexist.ps1\"/)
130 |     end
131 | 
132 |     it "should be invalid if 'configuration_data_file' is not a real file" do
133 |       subject.manifests_path = "/"
134 |       subject.configuration_data_file = "/oeu/aoeu/notexist.psd1"
135 |       assert_invalid
136 |       assert_error(/\"Path to DSC Configuration Data file does not exist: ([Cc]:)?\/oeu\/aoeu\/notexist.psd1\"/)
137 |     end
138 | 
139 |     it "should detect the fully qualified path to the configuration data file automatically" do
140 |       env = double("environment", root_path: "")
141 |       config = double("config")
142 |       allow(machine).to receive_messages(config: config, env: env)
143 |       allow(machine).to receive(:root_path).and_return(".")
144 | 
145 |       subject.configuration_data_file = "manifests/foo.psd1"
146 | 
147 |       subject.finalize!
148 |       subject.validate(machine)
149 | 
150 |       expect(subject.expanded_configuration_data_file.to_s).to match(/([Cc]:)?#{subject.temp_dir}\/manifests\/foo.psd1/)
151 |     end
152 | 
153 |     it "should be invalid if 'module_path' is not a real directory" do
154 |       subject.module_path = "/i/dont/exist"
155 |       assert_invalid
156 |       assert_error(/\"Path to DSC Modules does not exist: ([Cc]:)?\/i\/dont\/exist\"/)
157 |     end
158 | 
159 |     it "should be invalid if 'configuration_file' and 'mof_path' provided" do
160 |       mof = File.new(temporary_file)
161 |       man = File.new(temporary_file)
162 | 
163 |       subject.configuration_file = File.basename(man)
164 |       subject.mof_path = File.basename(mof)
165 |       expect { subject.finalize! }.to raise_error("\"Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two.\"")
166 |       # assert_error("\"Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two.\"")
167 |     end
168 | 
169 |     it "should be valid if 'configuration_file' is a real file" do
170 |       file = File.new(temporary_file)
171 | 
172 |       subject.configuration_file = File.basename(file)
173 |       subject.manifests_path = File.dirname(file)
174 |       subject.module_path = File.dirname(file)
175 |       assert_valid
176 |     end
177 |   end
178 | end


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Vagrant DSC Plugin
  2 | 
  3 | [![Build Status](https://travis-ci.org/mefellows/vagrant-dsc.svg)](https://travis-ci.org/mefellows/vagrant-dsc)
  4 | [![Coverage Status](https://coveralls.io/repos/mefellows/vagrant-dsc/badge.png?branch=master)](https://coveralls.io/r/mefellows/vagrant-dsc?branch=master)
  5 | [![Gem Version](https://badge.fury.io/rb/vagrant-dsc.svg)](http://badge.fury.io/rb/vagrant-dsc)
  6 | 
  7 | [Desired State Configuration](https://msdn.microsoft.com/en-us/powershell/dsc/overview) provisioning plugin for Vagrant, enabling you to quickly configure & bootstrap a Windows Virtual Machine in a repeatable, reliable fashion - the Vagrant way.
  8 | 
  9 | .NET Devs - no more excuses...
 10 | 
 11 | > But it works on my machine!?
 12 | 
 13 | ...is a thing of the past
 14 | 
 15 | ## Features
 16 | 
 17 | 1. Automated provisioning using [PowerShell DSC](https://msdn.microsoft.com/en-us/powershell/dsc/overview)
 18 | 2. Install modules from the [Powershell Gallery](https://www.powershellgallery.com/) 
 19 |    with PowerShellGet / PowerShell5
 20 | 3. Windows development machine from zero to dev-ready < 5 minutes!
 21 | 
 22 | ## Installation
 23 | 
 24 | ```vagrant plugin install vagrant-dsc```
 25 | 
 26 | ## Usage
 27 | 
 28 | In your Vagrantfile, add the following plugin and configure to your needs:
 29 | 
 30 | ```ruby
 31 |   config.vm.provision "dsc" do |dsc|
 32 | 
 33 |     # The path relative to `dsc.manifests_path` pointing to the Configuration file
 34 |     dsc.configuration_file  = "MyWebsite.ps1"
 35 | 
 36 |     # The Configuration Command to run. Assumed to be the same as the `dsc.configuration_file`
 37 |     # (sans extension) if not provided.
 38 |     dsc.configuration_name = "MyWebsite"
 39 | 
 40 |     # Commandline arguments to the Configuration run
 41 |     # Set of Parameters to pass to the DSC Configuration.
 42 |     #
 43 |     # To pass in flags, simply set the value to `nil`
 44 |     dsc.configuration_params = {"-MachineName" => "localhost", "-EnableDebug" => nil}
 45 | 
 46 |     # A path relative to the Vagrantfile pointing to a Configuration Data file.
 47 |     #
 48 |     # See https://technet.microsoft.com/en-us/library/dn249925.aspx for details
 49 |     # on how to parameterise your Configuration files.
 50 |     dsc.configuration_data_file  = "manifests/MyConfig.psd1"
 51 | 
 52 |     # Relative path to a folder containing a pre-generated MOF file.
 53 |     #
 54 |     # Path is relative to the folder containing the Vagrantfile.
 55 |     # When set, `configuration_name`, `configuration_data_file_path`,
 56 |     # `configuration_file_path`, `configuration_data_file` and
 57 |     # `manifests_path` are ignored.
 58 |     dsc.mof_path = "mof_output"
 59 | 
 60 |     # Relative path to the folder containing the root Configuration manifest file.
 61 |     # Defaults to 'manifests'.
 62 |     #
 63 |     # Path is relative to the folder containing the Vagrantfile.
 64 |     dsc.manifests_path = "manifests"
 65 | 
 66 |     # Set of module paths relative to the Vagrantfile dir.
 67 |     #
 68 |     # These paths are added to the DSC Configuration running
 69 |     # environment to enable local modules to be addressed.
 70 |     dsc.module_path = ["manifests", "modules"]
 71 | 
 72 |     # Set of modules to install from the PowerShell Gallery 
 73 |     # (https://www.powershellgallery.com/).
 74 |     #
 75 |     # Requires PowerShell 5 or PowerShellGet installed on guest machine.
 76 |     #
 77 |     # These modules are downloaded and installed when provisioning,
 78 |     # if a module is already installed it is a no-op.
 79 |     dsc.module_install = ["xNetworking", "xComputerManagement"]
 80 | 
 81 |     # The type of synced folders to use when sharing the data
 82 |     # required for the provisioner to work properly.
 83 |     #
 84 |     # By default this will use the default synced folder type.
 85 |     # For example, you can set this to "nfs" to use NFS synced folders.
 86 |     dsc.synced_folder_type = "nfs"
 87 | 
 88 |     # Whether to abort the vagrant run if DSC fails.
 89 |     #
 90 |     # By default, this is false.
 91 |     dsc.abort_on_dsc_failure = true
 92 | 
 93 |     # Temporary working directory on the guest machine.
 94 |     dsc.temp_dir = "/tmp/vagrant-dsc"
 95 |   end
 96 | ```
 97 | 
 98 | ### Specifying a MOF file
 99 | 
100 | If `mof_path` is set then `configuration_name`, `configuration_data_file_path`, `configuration_file_path`, `configuration_data_file` and `manifests_path` are all not required, and will be ignored. Once you have a MOF file, you have everything you need (except possibly any paths to modules i.e. `module_paths`) to execute DSC
101 | 
102 | If you don't know what a MOF file is, you probably don't need it and can safely ignore this setting.
103 | Vagrant DSC will create and manage it for you automatically.
104 | 
105 | ## Example
106 | 
107 | There is a [sample](https://github.com/mefellows/vagrant-dsc/tree/master/development/web) 
108 | Vagrant setup used for development of this plugin. This is a great real-life example 
109 | to get you on your way.
110 | 
111 | ## Creating Windows Vagrant boxes
112 | 
113 | Look at some example Packer templates [here](https://github.com/mefellows/packer-windows-templates/).
114 | 
115 | ## Roadmap
116 | 
117 | * Support DSC Pull Server provisioning
118 | * Test (dry-run) a DSC Configuration Run with 'vagrant vagrant-dsc test'
119 | * Support for non-Windows environments
120 | 
121 | ### Supported Environments
122 | 
123 | Currently the plugin only supports modern Windows environments with DSC installed (Windows 8.1+, Windows Server 2012 R2+ are safe bets).
124 | The plugin works on older platforms that have a later version of .NET (4.5) and the WMF 4.0 installed.
125 | 
126 | As a general guide, configuring your Windows Server
127 | 
128 | From the [DSC Book](https://www.penflip.com/powershellorg/the-dsc-book):
129 | 
130 | > **DSC Overview and Requirements**
131 | > Desired State Configuration (DSC) was first introduced as part of Windows Management Framework (WMF) 4.0, which is preinstalled in Windows 8.1 and Windows Server 2012 R2, and is available for Windows 7, Windows Server 2008 R2, and Windows Server 2012. Because Windows 8.1 is a free upgrade to Windows 8, WMF 4 is not available for Windows 8.
132 | > You must have WMF 4.0 on a computer if you plan to author configurations there. You must also have WMF 4.0 on any computer you plan to manage via DSC. Every computer involved in the entire DSC conversation must have WMF 4.0 installed. Period. Check $PSVersionTable in PowerShell if you’re not sure what version is installed on a computer.
133 | > On Windows 8.1 and Windows Server 2012 R2, make certain that KB2883200 is installed or DSC will not work. On Windows Server 2008 R2, Windows 7, and Windows Server 2008, be sure to install the full Microsoft .NET Framework 4.5 package prior to installing WMF 4.0 or DSC may not work correctly.
134 | 
135 | We may consider automatically installing and configuring DSC in a future release of the plugin.
136 | 
137 | ## Uninstallation
138 | 
139 | ```vagrant plugin uninstall vagrant-dsc```
140 | 
141 | ## Development
142 | 
143 | 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.
144 | 
145 | You will need Ruby 2.1.5 and Bundler v1.12.5 installed before proceeding.
146 | 
147 | _NOTE_: it _must_ be bundler v1.12.5 due to a hard dependency in Vagrant at this time.
148 | 
149 | ```
150 | git clone git@github.com:mefellows/vagrant-dsc.git
151 | cd vagrant-dsc
152 | bundle install
153 | ```
154 | 
155 | Run tests:
156 | ```
157 | bundle exec rake spec
158 | ```
159 | 
160 | Run Vagrant in context of current vagrant-dsc plugin:
161 | ```
162 | cd <directory>
163 | bundle exec vagrant up
164 | ```
165 | 
166 | There is a test Vagrant DSC setup in `./development` that is a good example of a simple acceptance test.
167 | 
168 | ### Multiple Bundlers?
169 | 
170 | If you have multiple Bundler versions, you can still use 1.12.5 with the following:
171 | 
172 | ```
173 | bundle _1.12.5_ <command>
174 | ```
175 | 
176 | e.g. `bundle _1.12.5_ exec rake spec`
177 | 
178 | ### Visual Studio Code
179 | 
180 | You can run the test from Visual Studio Code. This needs the binstubs from bundler. Run
181 | ```
182 | bundler install --binstubs
183 | ```
184 | to get them.
185 | 
186 | After this you can run the tests with F5.
187 | 
188 | ## Contributing
189 | 
190 | 1. Fork it ( https://github.com/[my-github-username]/vagrant-dsc/fork )
191 | 1. Create your feature branch (`git checkout -b my-new-feature`)
192 | 1. Commit your changes, including relevant tests (`git commit -am 'Add some feature'`)
193 | 1. Squash commits & push to the branch (`git push origin my-new-feature`)
194 | 1. Create a new Pull Request
195 | 


--------------------------------------------------------------------------------
/lib/vagrant-dsc/config.rb:
--------------------------------------------------------------------------------
  1 | require "vagrant/util/counter"
  2 | require "log4r"
  3 | 
  4 | module VagrantPlugins
  5 |   module DSC
  6 |     # The "Configuration" represents a configuration of how the DSC
  7 |     # provisioner should behave: data directories, working directory,
  8 |     # DSC Manifests etc.
  9 |     class Config < Vagrant.plugin("2", :config)
 10 |       extend Vagrant::Util::Counter
 11 | 
 12 |       # Set of Parameters to pass to the DSC Configuration.
 13 |       #
 14 |       # @return [Hash] Set of k/v parameters to pass to DSC.
 15 |       attr_accessor :configuration_params
 16 | 
 17 |       # Relative path to a folder, containing the pre-generated MOF file.
 18 |       #
 19 |       # Path is relative to the folder containing the Vagrantfile.
 20 |       attr_accessor :mof_path
 21 | 
 22 |       # Relative path to the DSC Configuration file.
 23 |       #
 24 |       # Path is relative to the folder containing the Vagrantfile.
 25 |       attr_accessor :configuration_file
 26 | 
 27 |       # Relative path to the DSC Configuration Data file.
 28 |       # 
 29 |       # Configuration data is used to parameterise the configuration_file.
 30 |       #
 31 |       # Path is relative to the folder containing the Vagrantfile.
 32 |       attr_accessor :configuration_data_file
 33 | 
 34 |       # Relative path to the folder containing the root Configuration manifest file.
 35 |       # Defaults to 'manifests'.
 36 |       #
 37 |       # Path is relative to the folder containing the Vagrantfile.
 38 |       attr_accessor :manifests_path
 39 | 
 40 |       # The name of the Configuration module
 41 |       #
 42 |       # Defaults to the basename of the "configuration_file"
 43 |       # e.g. "Foo.ps1" becomes "Foo"
 44 |       attr_accessor :configuration_name
 45 | 
 46 |       # Set of module paths relative to the Vagrantfile dir.
 47 |       #
 48 |       # These paths are added to the DSC Configuration running
 49 |       # environment to enable local modules to be addressed.
 50 |       #
 51 |       # @return [Array] Set of relative module paths.
 52 |       attr_accessor :module_path
 53 | 
 54 |       # The type of synced folders to use when sharing the data
 55 |       # required for the provisioner to work properly.
 56 |       #
 57 |       # By default this will use the default synced folder type.
 58 |       # For example, you can set this to "nfs" to use NFS synced folders.
 59 |       attr_accessor :synced_folder_type
 60 | 
 61 |       # Temporary working directory on the guest machine.
 62 |       attr_accessor :temp_dir
 63 | 
 64 |       # Modules to install
 65 |       attr_accessor :module_install
 66 | 
 67 |       # Fully qualified path to the configuration file.
 68 |       #
 69 |       # Do not override this.
 70 |       attr_accessor :expanded_configuration_file
 71 | 
 72 |       # Fully qualified path to the configuration data file.
 73 |       #
 74 |       # Do not override this.
 75 |       attr_accessor :expanded_configuration_data_file
 76 | 
 77 |       attr_accessor :abort_on_dsc_failure
 78 | 
 79 |       def initialize
 80 |         super
 81 | 
 82 |         @configuration_file             = UNSET_VALUE
 83 |         @configuration_data_file        = UNSET_VALUE
 84 |         @manifests_path                 = UNSET_VALUE
 85 |         @configuration_name             = UNSET_VALUE
 86 |         @mof_path                       = UNSET_VALUE
 87 |         @module_path                    = UNSET_VALUE
 88 |         @configuration_params           = {}
 89 |         @synced_folder_type             = UNSET_VALUE
 90 |         @temp_dir                       = UNSET_VALUE
 91 |         @module_install                 = UNSET_VALUE
 92 |         @abort_on_dsc_failure = UNSET_VALUE
 93 |         @logger = Log4r::Logger.new("vagrant::vagrant_dsc")
 94 |       end
 95 | 
 96 |       # Final step of the Configuration lifecyle prior to
 97 |       # validation.
 98 |       #
 99 |       # Ensures all attributes are set to defaults if not provided.
100 |       def finalize!
101 |         super
102 | 
103 |         # Null checks
104 |         @configuration_file             = "default.ps1" if @configuration_file == UNSET_VALUE
105 |         @configuration_data_file        = nil if @configuration_data_file == UNSET_VALUE
106 |         @module_path                    = nil if @module_path == UNSET_VALUE
107 |         @synced_folder_type             = nil if @synced_folder_type == UNSET_VALUE
108 |         @temp_dir                       = nil if @temp_dir == UNSET_VALUE
109 |         @module_install                 = nil if @module_install == UNSET_VALUE
110 |         @mof_path                       = nil if @mof_path == UNSET_VALUE
111 |         @configuration_name             = File.basename(@configuration_file, File.extname(@configuration_file)) if @configuration_name == UNSET_VALUE
112 |         @manifests_path                 = File.dirname(@configuration_file) if @manifests_path == UNSET_VALUE
113 |         @abort_on_dsc_failure = false if @abort_on_dsc_failure == UNSET_VALUE
114 | 
115 |         # Can't supply them both!
116 |         if (@configuration_file != nil && @mof_path != nil)
117 |           raise DSCError, :manifest_and_mof_provided
118 |         end
119 | 
120 |         # Set a default temp dir that has an increasing counter so
121 |         # that multiple DSC definitions won't overwrite each other
122 |         if !@temp_dir
123 |           counter   = self.class.get_and_update_counter(:dsc_config)
124 |           @temp_dir = "/tmp/vagrant-dsc-#{counter}"
125 |         end
126 |       end
127 | 
128 |       # Returns the module paths as an array of paths expanded relative to the
129 |       # root path.
130 |       #
131 |       # @param [String|Array] root_path The relative path to expand module paths against.
132 |       # @return [Array] Set of fully qualified paths to the modules directories.
133 |       def expanded_module_paths(root_path)
134 |         return [] if !module_path
135 | 
136 |         # Get all the paths and expand them relative to the root path, returning
137 |         # the array of expanded paths
138 |         paths = module_path
139 |         paths = [paths] if !paths.is_a?(Array)
140 |         paths.map do |path|
141 |           Pathname.new(path).expand_path(root_path).to_s
142 |         end
143 |       end
144 | 
145 |       # Validate configuration and return a hash of errors.
146 |       #
147 |       # Does not check that DSC itself is properly configured, which is performed
148 |       # at run-time.
149 |       #
150 |       # @param [Machine] The current {Machine}
151 |       # @return [Hash] Any errors or {} if no errors found
152 |       def validate(machine)
153 |         @logger.info("==> Configuring DSC")
154 |         errors = _detected_errors
155 | 
156 |         # Calculate the manifests and module paths based on env
157 |         local_expanded_module_paths = expanded_module_paths(machine.env.root_path)
158 | 
159 |         # Manifest file validation
160 |         local_expanded_module_paths.each do |path|
161 |           errors << I18n.t("vagrant_dsc.errors.module_path_missing", path: path) if !Pathname.new(path).expand_path(machine.env.root_path).directory?
162 |         end
163 | 
164 |         host_manifest_path = Pathname.new(manifests_path).expand_path(machine.env.root_path)
165 | 
166 |         if !host_manifest_path.directory?
167 |           errors << I18n.t("vagrant_dsc.errors.manifests_path_missing",
168 |                            path: host_manifest_path.to_s)
169 |         end
170 | 
171 |         # Path to manifest file on the host machine must exist
172 |         host_expanded_configuration_file = host_manifest_path.join(File.basename(configuration_file))
173 |         if !host_expanded_configuration_file.file? && !host_expanded_configuration_file.directory?
174 |           errors << I18n.t("vagrant_dsc.errors.manifest_missing",
175 |                            manifest: host_expanded_configuration_file.to_s)
176 |         end
177 | 
178 |         # Set absolute path to manifest file on the guest
179 |         @expanded_configuration_file = Pathname.new(File.dirname(configuration_file)).expand_path(temp_dir).join(File.basename(configuration_file))
180 | 
181 |         # Check path of the configuration data file on host
182 |         if configuration_data_file != nil
183 | 
184 |           host_expanded_path = Pathname.new(File.dirname(configuration_data_file)).expand_path(machine.env.root_path)
185 |           expanded_host_configuration_data_file = host_expanded_path.join(File.basename(configuration_data_file))
186 | 
187 |           if !expanded_host_configuration_data_file.file? && !expanded_host_configuration_data_file.directory?
188 |             errors << I18n.t("vagrant_dsc.errors.configuration_data_missing",
189 |                              path: expanded_host_configuration_data_file.to_s)
190 |           end
191 | 
192 |           @expanded_configuration_data_file = Pathname.new(File.dirname(configuration_data_file)).expand_path(temp_dir).join(File.basename(configuration_data_file))
193 |         end
194 | 
195 |         { "dsc provisioner" => errors }
196 |       end
197 |     end
198 |   end
199 | end
200 | 


--------------------------------------------------------------------------------
/lib/vagrant-dsc/provisioner.rb:
--------------------------------------------------------------------------------
  1 | require "log4r"
  2 | require 'erb'
  3 | 
  4 | module VagrantPlugins
  5 |   module DSC
  6 |     # DSC Errors namespace, including setup of locale-based error messages.
  7 |     class DSCError < Vagrant::Errors::VagrantError
  8 |       error_namespace("vagrant_dsc.errors")
  9 |       I18n.load_path << File.expand_path("locales/en.yml", File.dirname(__FILE__))
 10 |     end
 11 |     class DSCUnsupportedOperation < DSCError
 12 |       error_key(:unsupported_operation)
 13 |     end
 14 | 
 15 |     # DSC Provisioner Plugin.
 16 |     #
 17 |     # Runs the [Desired State Configuration](http://technet.microsoft.com/en-au/library/dn249912.aspx) system
 18 |     # on a guest Virtual Machine, enabling you to quickly configure & bootstrap a Windows Virtual Machine in a repeatable,
 19 |     # reliable fashion - the Vagrant way.
 20 |     class Provisioner < Vagrant.plugin("2", :provisioner)
 21 |       PowerShell_VERSION = 4
 22 | 
 23 |       # Default path for storing the transient script runner
 24 |       # This should be removed in cleanup
 25 |       DSC_GUEST_RUNNER_PATH = "c:/tmp/vagrant-dsc-runner.ps1"
 26 | 
 27 |       # Constructs the Provisioner Plugin.
 28 |       #
 29 |       # @param [Machine] machine The guest machine that is to be provisioned.
 30 |       # @param [Config] config The Configuration object used by the Provisioner.
 31 |       # @returns Provisioner
 32 |       def initialize(machine, config)
 33 |         super
 34 | 
 35 |         @logger = Log4r::Logger.new("vagrant::provisioners::dsc")
 36 |       end
 37 | 
 38 |       # Configures the Provisioner.
 39 |       #
 40 |       # @param [Config] root_config The default configuration from the Vagrant hierarchy.
 41 |       def configure(root_config)
 42 |         @logger.info("==> Configuring DSC")
 43 | 
 44 |         # Calculate the paths we're going to use based on the environment
 45 |         root_path = @machine.env.root_path
 46 |         @expanded_module_paths   = @config.expanded_module_paths(root_path)
 47 | 
 48 |         # Setup the module paths
 49 |         @module_paths = []
 50 |         @expanded_module_paths.each_with_index do |path, i|
 51 |           @module_paths << [path, File.join(config.temp_dir, "modules-#{i}")]
 52 |         end
 53 | 
 54 |         folder_opts = {}
 55 |         folder_opts[:type] = @config.synced_folder_type if @config.synced_folder_type
 56 |         folder_opts[:owner] = "root" if !@config.synced_folder_type
 57 | 
 58 |         # Share the manifests directory with the guest
 59 |         @logger.info("==> Sharing manifest #{File.expand_path(@config.manifests_path, root_path)} | #{manifests_guest_path} | #{folder_opts}")
 60 | 
 61 |         root_config.vm.synced_folder(
 62 |           File.expand_path(@config.manifests_path, root_path),
 63 |           manifests_guest_path, folder_opts)
 64 | 
 65 |         # Share the module paths
 66 |         @module_paths.each do |from, to|
 67 |           @logger.info("==> Sharing module folders #{from} | #{to}")
 68 |           root_config.vm.synced_folder(from, to, folder_opts)
 69 |         end
 70 |       end
 71 | 
 72 |       # Provision the guest machine with DSC.
 73 |       def provision
 74 |         @logger.info("==> Provisioning DSC man! #{Vagrant.source_root}")
 75 | 
 76 |         # If the machine has a wait for reboot functionality, then
 77 |         # do that (primarily Windows)
 78 |         if @machine.guest.capability?(:wait_for_reboot)
 79 |           @machine.guest.capability(:wait_for_reboot)
 80 |         end
 81 | 
 82 |         # Check that the shared folders are properly shared
 83 |         check = []
 84 |         check << manifests_guest_path
 85 |         @module_paths.each do |host_path, guest_path|
 86 |           check << guest_path
 87 |         end
 88 | 
 89 |         # Make sure the temporary directory is properly set up
 90 |         @machine.communicate.tap do |comm|
 91 |           comm.sudo("mkdir -p #{config.temp_dir}")
 92 |           comm.sudo("chmod 0777 #{config.temp_dir}")
 93 |         end
 94 | 
 95 |         verify_shared_folders(check)
 96 | 
 97 |         verify_dsc
 98 | 
 99 |         write_dsc_runner_script(generate_dsc_runner_script)
100 | 
101 |         begin
102 |           run_dsc_apply
103 |         rescue VagrantPlugins::CommunicatorWinRM::Errors::AuthenticationFailed
104 |           # when install set a domain controller windows kills the active connection with a AuthenticationFailed.
105 |           # The DSC job is still running and new connections are possible, so try to wait 
106 |           @machine.ui.info(I18n.t("vagrant_dsc.errors.winrm_authorization_error_recover"))
107 |         end
108 |         
109 |         wait_for_dsc_completion
110 |       end
111 | 
112 |       # Waits for the completion of the dsc configuration if dsc needs reboots. This currntly only works for WMF5 and needs wait_for_reboot
113 |       def wait_for_dsc_completion
114 |         powershell_version = get_guest_powershell_version
115 |         return if powershell_version.to_i < 5 || !@machine.guest.capability?(:wait_for_reboot)
116 |         dsc_running = true
117 | 
118 |         while dsc_running
119 |           case get_lcm_state
120 |             when "PendingReboot"
121 |               @machine.ui.info("DSC needs reboot. Wait for the completion of DSC.")
122 |               @machine.guest.capability(:wait_for_reboot)
123 | 
124 |             # Do not Know a way to reattch to dsc job, therefore check periodically the state
125 |             when "Busy"
126 |               sleep 10
127 |             else
128 |               dsc_running = false
129 |           end
130 |         end
131 | 
132 |         if (get_configuration_status == "Failure")
133 |           @machine.ui.error(I18n.t("vagrant_dsc.errors.failure_status"))
134 |           show_dsc_failure_message
135 |           fail_vagrant_run_if_requested
136 |         end
137 |       end
138 | 
139 |       def get_guest_powershell_version
140 |         version = @machine.communicate.shell.powershell("$PSVersionTable.PSVersion.Major")
141 |         return version[:data][0][:stdout]
142 |       end
143 | 
144 |       def get_lcm_state
145 |         state = @machine.communicate.shell.powershell("(Get-DscLocalConfigurationManager).LCMState")
146 |         return state[:data][0][:stdout]
147 |       end
148 | 
149 |       def get_configuration_status
150 |         status = @machine.communicate.shell.powershell("(Get-DscConfigurationStatus).Status")
151 |         return status[:data][0][:stdout]
152 |       end
153 | 
154 |       def show_dsc_failure_message
155 |         dsc_error_ps = "Get-WinEvent \"Microsoft-Windows-Dsc/Operational\" | Where-Object {$_.LevelDisplayName -eq \"Error\" -and $_.Message.StartsWith(\"Job $((Get-DscConfigurationStatus).JobId)\" )} | foreach { $_.Message }"
156 |         @machine.communicate.shell.powershell(dsc_error_ps) do |type,data|
157 |           @machine.ui.error(data, prefix: false)
158 |         end
159 |       end
160 | 
161 |       def fail_vagrant_run_if_requested
162 |         if (@config.abort_on_dsc_failure)
163 |           raise DSCError, :dsc_configuration_failed
164 |         else
165 |           @machine.ui.info("DSC execution failed. Set 'abort_on_dsc_failure' to true to make this fail the build.")
166 |         end
167 |       end
168 | 
169 |       # Cleanup after a destroy action.
170 |       #
171 |       # This is the method called when destroying a machine that allows
172 |       # for any state related to the machine created by the provisioner
173 |       # to be cleaned up.
174 |       def cleanup
175 |         # Remove temp files? Or is this ONLY called in destroy (in which case those files will go anyway...)
176 |       end
177 | 
178 |       # Local path (guest path) to the manifests directory.
179 |       def manifests_guest_path
180 |           File.join(config.temp_dir, config.manifests_path)
181 |       end
182 | 
183 |       # Verify that a current version of WMF/Powershell is enabled on the guest.
184 |       def verify_dsc
185 |         verify_binary("Start-DscConfiguration")
186 | 
187 |         # Confirm WMF 4.0+ in $PSVersionTable
188 |         @machine.communicate.test(
189 |             "(($PSVersionTable | ConvertTo-json | ConvertFrom-Json).PSVersion.Major) -ge #{PowerShell_VERSION}",
190 |             error_class: DSCError,
191 |             error_key: :dsc_incorrect_PowerShell_version )
192 |       end
193 | 
194 |       # Verify the DSC binary is executable on the guest machine.
195 |       def verify_binary(binary)
196 |         @machine.communicate.sudo(
197 |           "which #{binary}",
198 |           error_class: DSCError,
199 |           error_key: :dsc_not_detected,
200 |           binary: binary)
201 |       end
202 | 
203 |       # Install and Configure DSC where possible.
204 |       #
205 |       # Operation is current unsupported, but is likely to be enabled
206 |       # as a flag when the plugin detects an unsupported OS.
207 |       def install_dsc
208 |         raise DSCUnsupportedOperation,  :operation => "install_dsc"
209 |       end
210 | 
211 |       # Generates a PowerShell DSC runner script from an ERB template
212 |       #
213 |       # @return [String] The interpolated PowerShell script.
214 |       def generate_dsc_runner_script
215 |         path = File.expand_path("../templates/runner.ps1", __FILE__)
216 | 
217 |         script = Vagrant::Util::TemplateRenderer.render(path, options: {
218 |             config: @config,
219 |             module_paths: @module_paths.map { |k,v| v }.join(";"),
220 |             mof_path: @config.mof_path,
221 |             configuration_file: @config.configuration_file,
222 |             configuration_file_path: "#{@config.manifests_path}/#{File.basename @config.configuration_file}",
223 |             configuration_data_file_path: @config.configuration_data_file,
224 |             configuration_name: @config.configuration_name,
225 |             manifests_path: @config.manifests_path,
226 |             temp_path: @config.temp_dir,
227 |             module_install: @config.module_install.nil? ? "" : @config.module_install.join(";"),
228 |             parameters: @config.configuration_params.map { |k,v| "#{k}" + (!v.nil? ? " \"#{v}\"": '') }.join(" ")
229 |         })
230 |       end
231 | 
232 |       # Writes the PowerShell DSC runner script to a location on the guest.
233 |       #
234 |       # @param [String] script The PowerShell DSC runner script.
235 |       # @return [String] the Path to the uploaded location on the guest machine.
236 |       def write_dsc_runner_script(script)
237 |         guest_script_path = DSC_GUEST_RUNNER_PATH
238 |         file = Tempfile.new(["vagrant-dsc-runner", "ps1"])
239 |         begin
240 |           file.write(script)
241 |           file.fsync
242 |           file.close
243 |           @machine.communicate.upload(file.path, guest_script_path)
244 |         ensure
245 |           file.close
246 |           file.unlink
247 |         end
248 |         guest_script_path
249 |       end
250 | 
251 |       # Runs the DSC Configuration on the guest machine.
252 |       def run_dsc_apply
253 | 
254 |         @machine.ui.info(I18n.t(
255 |           "vagrant_dsc.running_dsc",
256 |           manifest: config.configuration_file))
257 | 
258 |         # A bit of an ugly dance, but this is how we get neat, colourised output and exit codes from a Powershell run
259 |         error = false
260 |         machine.communicate.shell.powershell("powershell -ExecutionPolicy Bypass -OutputFormat Text -file #{DSC_GUEST_RUNNER_PATH}") do |type, data|
261 |           if !data.chomp.empty?
262 |             error = true if type == :stderr
263 |             if [:stderr, :stdout].include?(type)
264 |               color = type == :stdout ? :green : :red
265 |               # Remove the \r\n since the dsc output uses this if line is to long. A Line break is a simple \n
266 |               data = data.gsub(/\r\n/,"") if type == :stdout
267 |               @machine.ui.info( data.strip(), color: color, prefix: false)
268 |             end
269 |           end
270 |         end
271 | 
272 |         error == false
273 |       end
274 | 
275 |       # Verify that the shared folders have been properly configured
276 |       # on the guest machine.
277 |       def verify_shared_folders(folders)
278 |         folders.each do |folder|
279 |           # Warm up PoSH communicator for new instances - any stderr results
280 |           # in failure: https://github.com/mefellows/vagrant-dsc/issues/21
281 |           @machine.communicate.test("test -d #{folder}", sudo: true)
282 | 
283 |           @logger.info("Checking for shared folder: #{folder}")
284 |           if !@machine.communicate.test("test -d #{folder}", sudo: true)
285 |             raise DSCError, :missing_shared_folders
286 |           end
287 |         end
288 |       end
289 | 
290 |       # If on using WinRM, we can assume we are on Windows
291 |       def windows?
292 |         @machine.config.vm.communicator == :winrm
293 |       end
294 |     end
295 |   end
296 | end
297 | 


--------------------------------------------------------------------------------
/spec/provisioner/provisioner_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | require 'vagrant-dsc/provisioner'
  3 | require 'vagrant-dsc/config'
  4 | require 'rspec/its'
  5 | 
  6 | describe VagrantPlugins::DSC::Provisioner do
  7 |   include_context "unit"
  8 | 
  9 |   let(:root_path)               { (Pathname.new(Dir.mktmpdir)).to_s }
 10 |   let(:ui)                      { Vagrant::UI::Silent.new }
 11 |   let(:machine)                 { double("machine", ui: ui) }
 12 |   let(:env)                     { double("environment", root_path: root_path, ui: ui) }
 13 |   let(:vm)                      { double ("vm") }
 14 |   let(:shell)                   { double ("shell") }
 15 |   let(:communicator)            { double ("communicator") }
 16 |   let(:guest)                   { double ("guest") }
 17 |   let(:configuration_file)      { "manifests/MyWebsite.ps1" }
 18 |   let(:configuration_data_file) { "manifests/MyConfig.psd1" }
 19 |   let(:module_path)             { ["foo/modules", "foo/modules2"] }
 20 |   let(:root_config)             { VagrantPlugins::DSC::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 |       allow(machine).to receive_messages(config: root_config, env: env)
 27 |       root_config.module_path = module_path
 28 |       root_config.configuration_file = configuration_file
 29 |       root_config.finalize!
 30 |       root_config.validate(machine)
 31 |     end
 32 | 
 33 |     it "should confirm if the OS is Windows by confirming with the communicator" do
 34 |       allow(root_config).to receive(:vm).and_return(vm)
 35 |       allow(vm).to receive(:communicator).and_return(:winrm)
 36 |       expect(subject.windows?).to eq(true)
 37 |     end
 38 | 
 39 |     it "when given default configuration, should share module and manifest folders with the guest" do
 40 |       allow(root_config).to receive(:vm).and_return(vm)
 41 |       expect(vm).to receive(:synced_folder).with("#{root_path}/manifests", /\/tmp\/vagrant-dsc-[0-9]+\/manifests/, {:owner=>"root"})
 42 |       expect(vm).to receive(:synced_folder).with("#{root_path}/foo/modules", /\/tmp\/vagrant-dsc-[0-9]+\/modules-0/, {:owner=>"root"})
 43 |       expect(vm).to receive(:synced_folder).with("#{root_path}/foo/modules2", /\/tmp\/vagrant-dsc-[0-9]+\/modules-1/, {:owner=>"root"})
 44 | 
 45 |       subject.configure(root_config)
 46 |     end
 47 | 
 48 |     it "when given a specific folder type, should modify folder options when sharing module and manifest folders with the guest" do
 49 |       root_config.synced_folder_type = "nfs"
 50 |       allow(root_config).to receive(:vm).and_return(vm)
 51 | 
 52 |       expect(vm).to receive(:synced_folder).with("#{root_path}/manifests", /\/tmp\/vagrant-dsc-[0-9]+\/manifests/, {:type=>"nfs"})
 53 |       expect(vm).to receive(:synced_folder).with("#{root_path}/foo/modules", /\/tmp\/vagrant-dsc-[0-9]+\/modules-0/, {:type=>"nfs"})
 54 |       expect(vm).to receive(:synced_folder).with("#{root_path}/foo/modules2", /\/tmp\/vagrant-dsc-[0-9]+\/modules-1/, {:type=>"nfs"})
 55 | 
 56 |       subject.configure(root_config)
 57 |     end
 58 | 
 59 |     it "when provided only manifests path, should only share manifest folders with the guest" do
 60 |       root_config.synced_folder_type = "nfs"
 61 |       root_config.module_path = nil
 62 |       allow(root_config).to receive(:vm).and_return(vm)
 63 | 
 64 |       expect(vm).to receive(:synced_folder).with("#{root_path}/manifests", /\/tmp\/vagrant-dsc-[0-9]+\/manifests/, {:type=>"nfs"})
 65 | 
 66 |       subject.configure(root_config)
 67 |     end
 68 | 
 69 |     it "should install DSC for supported OS's" do
 70 |       expect { subject.install_dsc }.to raise_error("\"Operation unsupported / not-yet implemented: install_dsc\"")
 71 | 
 72 | 
 73 |       # "Operation unsupported / not-yet implemented: install_dsc"
 74 |       # expect { subject.install_dsc }.to raise_error(VagrantPlugins::DSC::DSCError)
 75 |     end
 76 |   end
 77 | 
 78 |   describe "verify shared folders" do
 79 | 
 80 |     before do
 81 |       allow(machine).to receive(:root_config).and_return(root_config)
 82 |       allow(machine).to receive_messages(config: root_config, env: env, communicate: communicator)
 83 |       root_config.module_path = module_path
 84 |       root_config.configuration_file = configuration_file
 85 |       root_config.finalize!
 86 |       root_config.validate(machine)
 87 |     end
 88 | 
 89 |     it "should raise error if folders not shared" do
 90 |       root_config.synced_folder_type = "nfs"
 91 | 
 92 |       expect(communicator).to receive(:test).twice.with("test -d foo/modules", {:sudo=>true}).and_return(false)
 93 | 
 94 |       subject.configure(root_config)
 95 | 
 96 |       folders = module_path << File.dirname(configuration_file)
 97 |       expect { subject.verify_shared_folders(folders) }.to raise_error("Shared folders not properly configured. This is generally resolved by a 'vagrant halt && vagrant up'")
 98 |     end
 99 | 
100 |     it "should ensure shared folders are properly shared" do
101 |       root_config.synced_folder_type = "nfs"
102 | 
103 |       expect(communicator).to receive(:test).twice.with("test -d foo/modules", {:sudo=>true}).and_return(true)
104 |       expect(communicator).to receive(:test).twice.with("test -d foo/modules2", {:sudo=>true}).and_return(true)
105 |       expect(communicator).to receive(:test).twice.with("test -d manifests", {:sudo=>true}).and_return(true)
106 | 
107 |       subject.configure(root_config)
108 | 
109 |       folders = module_path << File.dirname(configuration_file)
110 |       subject.verify_shared_folders(folders)
111 |     end
112 |   end
113 | 
114 |   describe "provision" do
115 | 
116 |     before do
117 |       # allow(root_config).to receive(:vm).and_return(vm)
118 |       allow(machine).to receive(:root_config).and_return(root_config)
119 |       allow(machine).to receive(:env).and_return(env)
120 |       root_config.module_path = module_path
121 |       root_config.configuration_file = configuration_file
122 |       root_config.finalize!
123 |       root_config.validate(machine)
124 |       subject.configure(root_config)
125 |       # allow(root_config).to receive(:vm).and_return(vm)
126 |       allow(machine).to receive_messages(config: root_config, env: env, communicate: communicator, guest: guest)
127 |     end
128 | 
129 |     it "should allow reboot capability when capability exists" do
130 |       allow(communicator).to receive(:sudo)
131 |       allow(communicator).to receive(:test)
132 |       allow(communicator).to receive(:upload)
133 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
134 |       allow(subject).to receive(:verify_dsc).and_return(true)
135 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
136 |       allow(subject).to receive(:wait_for_dsc_completion)
137 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
138 |       expect(guest).to receive(:capability).with(:wait_for_reboot)
139 | 
140 |       subject.provision
141 |     end
142 | 
143 |     it "should not allow reboot capability when capability does not exist" do
144 |       allow(communicator).to receive(:sudo)
145 |       allow(communicator).to receive(:test)
146 |       allow(communicator).to receive(:upload)
147 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
148 |       allow(subject).to receive(:verify_dsc).and_return(true)
149 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
150 |       allow(subject).to receive(:wait_for_dsc_completion) 
151 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(false)
152 |       expect(guest).to_not receive(:capability).with(:wait_for_reboot)
153 | 
154 |       subject.provision
155 |     end
156 | 
157 |     it "should create temporary folders on the guest" do
158 |       allow(communicator).to receive(:test)
159 |       allow(communicator).to receive(:upload)
160 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
161 |       allow(subject).to receive(:verify_dsc).and_return(true)
162 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
163 |       allow(subject).to receive(:wait_for_dsc_completion)
164 |       allow(guest).to receive(:capability?)
165 |       allow(guest).to receive(:capability)
166 | 
167 |       expect(communicator).to receive(:sudo).with("mkdir -p #{root_config.temp_dir}")
168 |       expect(communicator).to receive(:sudo).with("chmod 0777 #{root_config.temp_dir}")
169 | 
170 |       subject.provision
171 |     end
172 | 
173 |     it "should generate and write the runner script to the guest" do
174 |       allow(communicator).to receive(:test)
175 |       allow(communicator).to receive(:upload)
176 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
177 |       allow(subject).to receive(:verify_dsc).and_return(true)
178 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
179 |       allow(subject).to receive(:wait_for_dsc_completion)
180 |       allow(guest).to receive(:capability?)
181 |       allow(guest).to receive(:capability)
182 | 
183 |       expect(communicator).to receive(:sudo).with("mkdir -p #{root_config.temp_dir}")
184 |       expect(communicator).to receive(:sudo).with("chmod 0777 #{root_config.temp_dir}")
185 |       expect(subject).to receive(:verify_dsc)
186 |       expect(subject).to receive(:write_dsc_runner_script)
187 |       expect(subject).to receive(:run_dsc_apply)
188 | 
189 |       subject.provision
190 |     end
191 | 
192 |     it "should ensure shared folders are properly configured" do
193 |       allow(communicator).to receive(:test)
194 |       allow(communicator).to receive(:sudo)
195 |       allow(communicator).to receive(:upload)
196 |       allow(subject).to receive(:verify_dsc).and_return(true)
197 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
198 |       allow(subject).to receive(:wait_for_dsc_completion)
199 |       allow(guest).to receive(:capability?)
200 |       allow(guest).to receive(:capability)
201 | 
202 |       check = ["#{root_config.temp_dir}/manifests", "#{root_config.temp_dir}/modules-0", "#{root_config.temp_dir}/modules-1"]
203 |       expect(subject).to receive(:verify_shared_folders).with(check)
204 | 
205 |       subject.provision
206 |     end
207 | 
208 |     it "should provision wait for dsc" do
209 |       allow(communicator).to receive(:sudo)
210 |       allow(communicator).to receive(:test)
211 |       allow(communicator).to receive(:upload)
212 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
213 |       allow(subject).to receive(:verify_dsc).and_return(true)
214 |       allow(subject).to receive(:run_dsc_apply).and_return(true)
215 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
216 |       allow(guest).to receive(:capability).with(:wait_for_reboot)
217 |       expect(subject).to receive(:wait_for_dsc_completion)
218 | 
219 |       subject.provision
220 |     end
221 | 
222 |     it "should try to recover if AuthenticationFailed" do
223 |       allow(communicator).to receive(:sudo)
224 |       allow(communicator).to receive(:test)
225 |       allow(communicator).to receive(:upload)
226 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
227 |       allow(subject).to receive(:verify_dsc).and_return(true)
228 |       allow(subject).to receive(:run_dsc_apply).and_raise(VagrantPlugins::CommunicatorWinRM::Errors::AuthenticationFailed)
229 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
230 |       allow(guest).to receive(:capability).with(:wait_for_reboot)
231 |       expect(subject).to receive(:wait_for_dsc_completion)
232 | 
233 |       subject.provision
234 |     end
235 | 
236 |     it "should not try to recover from other exceptions" do
237 |       allow(communicator).to receive(:sudo)
238 |       allow(communicator).to receive(:test)
239 |       allow(communicator).to receive(:upload)
240 |       allow(subject).to receive(:verify_shared_folders).and_return(true)
241 |       allow(subject).to receive(:verify_dsc).and_return(true)
242 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
243 |       allow(guest).to receive(:capability).with(:wait_for_reboot)
244 |       allow(subject).to receive(:run_dsc_apply).and_raise()
245 | 
246 |       expect{ subject.provision }.to raise_error(RuntimeError)
247 |     end
248 | 
249 |     it "should wait for pending reboot" do
250 |       allow_any_instance_of(Object).to receive(:sleep)
251 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
252 |       allow(communicator).to receive(:shell).and_return(shell)
253 |       allow(subject).to receive(:get_lcm_state).and_return("PendingReboot", "Busy", "Sucess")
254 |       allow(subject).to receive(:get_configuration_status).and_return("Sucess")
255 |       allow(subject).to receive(:get_guest_powershell_version).and_return("5")
256 |       expect(guest).to receive(:capability).with(:wait_for_reboot)
257 | 
258 |       subject.wait_for_dsc_completion
259 |     end
260 | 
261 |     it "should wait for multi pending reboots" do
262 |       allow_any_instance_of(Object).to receive(:sleep)
263 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
264 |       allow(communicator).to receive(:shell).and_return(shell)
265 |       allow(subject).to receive(:get_lcm_state).and_return("PendingReboot", "Busy", "PendingReboot", "Busy", "Idle")
266 |       allow(subject).to receive(:get_configuration_status).and_return("Success")
267 |       allow(subject).to receive(:get_guest_powershell_version).and_return("5")
268 |       expect(guest).to receive(:capability).twice.with(:wait_for_reboot)
269 | 
270 |       subject.wait_for_dsc_completion
271 |     end
272 | 
273 |     it "should show error message on failure" do
274 |       allow_any_instance_of(Object).to receive(:sleep)
275 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
276 |       allow(communicator).to receive(:shell).and_return(shell)
277 |       allow(guest).to receive(:capability).with(:wait_for_reboot)
278 |       allow(subject).to receive(:get_lcm_state).and_return("PendingReboot", "Busy", "PendingConfiguration")
279 |       allow(subject).to receive(:get_configuration_status).and_return("Failure")
280 |       allow(subject).to receive(:get_guest_powershell_version).and_return("5")
281 |       expect(subject).to receive(:show_dsc_failure_message)
282 | 
283 |       subject.wait_for_dsc_completion
284 |     end
285 | 
286 |     it "should throw on failure if requested" do
287 |       allow_any_instance_of(Object).to receive(:sleep)
288 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
289 |       allow(communicator).to receive(:shell).and_return(shell)
290 |       allow(guest).to receive(:capability).with(:wait_for_reboot)
291 |       allow(subject).to receive(:get_lcm_state).and_return("PendingConfiguration")
292 |       allow(subject).to receive(:get_configuration_status).and_return("Failure")
293 |       allow(subject).to receive(:get_guest_powershell_version).and_return("5")
294 |       expect(subject).to receive(:show_dsc_failure_message)
295 |       allow(root_config).to receive(:abort_on_dsc_failure).and_return(true)
296 | 
297 |       expect{ subject.wait_for_dsc_completion }.to raise_error(VagrantPlugins::DSC::DSCError)
298 |     end
299 | 
300 |     it "should not get the lcm state if powershell version is 4" do
301 |       allow(guest).to receive(:capability?).with(:wait_for_reboot).and_return(true)
302 |       allow(communicator).to receive(:shell).and_return(shell)
303 |       allow(subject).to receive(:get_guest_powershell_version).and_return("4")
304 |       expect(subject).to_not receive(:get_lcm_state)
305 | 
306 |       subject.wait_for_dsc_completion
307 |     end
308 | 
309 |     it "should get the guest powershell version" do
310 |       allow(communicator).to receive(:shell).and_return(shell)
311 |       expect(shell).to receive(:powershell).with("$PSVersionTable.PSVersion.Major").and_return({:data => [{:stdout => "4"}]})
312 |       
313 |       expect(subject.get_guest_powershell_version).to eq("4")
314 |     end
315 | 
316 |     it "should get the lcm state" do
317 |       allow(communicator).to receive(:shell).and_return(shell)
318 |       expect(shell).to receive(:powershell).with("(Get-DscLocalConfigurationManager).LCMState").and_return({:data => [{:stdout => "LCMState"}]})
319 |       
320 |       expect(subject.get_lcm_state).to eq("LCMState")
321 |     end
322 | 
323 |     it "should get the configuration status" do
324 |       allow(communicator).to receive(:shell).and_return(shell)
325 |       expect(shell).to receive(:powershell).with("(Get-DscConfigurationStatus).Status").and_return({:data => [{:stdout => "Status"}]})
326 | 
327 |       expect(subject.get_configuration_status).to eq("Status")
328 |     end
329 | 
330 |     it "should get the dsc error message" do
331 |       allow(communicator).to receive(:shell).and_return(shell)
332 |       expect(shell).to receive(:powershell)
333 |         .with("Get-WinEvent \"Microsoft-Windows-Dsc/Operational\" | Where-Object {$_.LevelDisplayName -eq \"Error\" -and $_.Message.StartsWith(\"Job $((Get-DscConfigurationStatus).JobId)\" )} | foreach { $_.Message }")
334 |         .and_yield(:stdout, "\r\n")
335 |         .and_yield(:stdout, "\r\n")
336 |         .and_yield(:stdout, "Job AE9233FD-8491-11E6-9810-080027F3ADE1} : \r\n          MIResult: 1\r\n")
337 |       expect(ui).to receive(:error).with("\r\n", :prefix=>false).twice
338 |       expect(ui).to receive(:error).with("Job AE9233FD-8491-11E6-9810-080027F3ADE1} : \r\n          MIResult: 1\r\n", :prefix=>false)
339 | 
340 |       subject.show_dsc_failure_message
341 |     end
342 | 
343 |     it "should verify DSC binary exists" do
344 |       expect(communicator).to receive(:sudo).with("which Start-DscConfiguration", {:error_class=>VagrantPlugins::DSC::DSCError, :error_key=>:dsc_not_detected, :binary=>"Start-DscConfiguration"})
345 |       subject.verify_binary("Start-DscConfiguration")
346 |     end
347 | 
348 |     it "should verify DSC and Powershell versions are valid" do
349 |       expect(communicator).to receive(:test).with("(($PSVersionTable | ConvertTo-json | ConvertFrom-Json).PSVersion.Major) -ge 4", {:error_class=>VagrantPlugins::DSC::DSCError, :error_key=>:dsc_incorrect_PowerShell_version}).and_return(true)
350 |       allow(subject).to receive(:verify_binary).and_return(true)
351 |       subject.verify_dsc
352 |     end
353 | 
354 |     it "should raise an error if DSC version is invalid" do
355 |       expect(communicator).to receive(:test).with("(($PSVersionTable | ConvertTo-json | ConvertFrom-Json).PSVersion.Major) -ge 4", {:error_class=>VagrantPlugins::DSC::DSCError, :error_key=>:dsc_incorrect_PowerShell_version})
356 |       allow(subject).to receive(:verify_binary).and_return(true)
357 |       subject.verify_dsc
358 |     end
359 | 
360 |     it "should raise an error if Powershell version is invalid" do
361 | 
362 |     end
363 |   end
364 | 
365 |   describe "DSC runner script" do
366 |     before do
367 |       # Prevent counters messing with output in tests
368 |       Vagrant::Util::Counter.class_eval do
369 |         def get_and_update_counter(name=nil) 1 end
370 |       end
371 | 
372 |       allow(machine).to receive(:root_config).and_return(root_config)
373 |       root_config.configuration_file = configuration_file
374 |       allow(machine).to receive_messages(config: root_config, env: env)
375 |       root_config.module_path = module_path
376 |       root_config.configuration_file = configuration_file
377 |       root_config.finalize!
378 |       root_config.validate(machine)
379 |       subject.configure(root_config)
380 | 
381 |     end
382 | 
383 |     context "with default parameters" do
384 |       it "should generate a valid powershell command" do
385 |         script = subject.generate_dsc_runner_script
386 |         expect_script = "#
387 | # DSC Runner.
388 | #
389 | # Bootstraps the DSC environment, sets up configuration data
390 | # and runs the DSC Configuration.
391 | #
392 | #
393 | 
394 | # Set the local PowerShell Module environment path
395 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
396 | 
397 | echo \"Adding to path: $absoluteModulePaths\"
398 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
399 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
400 | 
401 | 
402 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
403 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
404 | echo \"\"
405 | echo \"Running Configuration file: ${script}\"
406 | 
407 | # Generate the MOF file, only if a MOF path not already provided.
408 | # Import the Manifest
409 | . $script
410 | 
411 | cd \"/tmp/vagrant-dsc-1\"
412 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
413 | MyWebsite -OutputPath $StagingPath 
414 | 
415 | # Start a DSC Configuration run
416 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
417 | del $StagingPath\\*.mof
418 | "
419 | 
420 |         expect(script).to eq(expect_script)
421 |       end
422 |     end
423 | 
424 |     context "with a relative manifests_path" do
425 |       it "should generate a valid powershell command" do
426 |         root_config.manifests_path = "../manifests"
427 |         root_config.configuration_file = configuration_file
428 | 
429 |         script = subject.generate_dsc_runner_script
430 |         expect_script = "#
431 | # DSC Runner.
432 | #
433 | # Bootstraps the DSC environment, sets up configuration data
434 | # and runs the DSC Configuration.
435 | #
436 | #
437 | 
438 | # Set the local PowerShell Module environment path
439 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
440 | 
441 | echo \"Adding to path: $absoluteModulePaths\"
442 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
443 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
444 | 
445 | 
446 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"../manifests/MyWebsite.ps1\" -Resolve)
447 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
448 | echo \"\"
449 | echo \"Running Configuration file: ${script}\"
450 | 
451 | # Generate the MOF file, only if a MOF path not already provided.
452 | # Import the Manifest
453 | . $script
454 | 
455 | cd \"/tmp/vagrant-dsc-1\"
456 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
457 | MyWebsite -OutputPath $StagingPath 
458 | 
459 | # Start a DSC Configuration run
460 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
461 | del $StagingPath\\*.mof
462 | "
463 | 
464 |         expect(script).to eq(expect_script)
465 |       end
466 |     end
467 | 
468 |     context "with custom DSC Parameters" do
469 |       it "should pass through arguments to the generated Powershell runner" do
470 |         root_config.configuration_params = {"-Foo" => "bar", "-ComputerName" => "catz"}
471 |         script = subject.generate_dsc_runner_script
472 | 
473 |         expect_script = "#
474 | # DSC Runner.
475 | #
476 | # Bootstraps the DSC environment, sets up configuration data
477 | # and runs the DSC Configuration.
478 | #
479 | #
480 | 
481 | # Set the local PowerShell Module environment path
482 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
483 | 
484 | echo \"Adding to path: $absoluteModulePaths\"
485 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
486 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
487 | 
488 | 
489 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
490 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
491 | echo \"\"
492 | echo \"Running Configuration file: ${script}\"
493 | 
494 | # Generate the MOF file, only if a MOF path not already provided.
495 | # Import the Manifest
496 | . $script
497 | 
498 | cd \"/tmp/vagrant-dsc-1\"
499 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
500 | MyWebsite -OutputPath $StagingPath -Foo \"bar\" -ComputerName \"catz\"
501 | 
502 | # Start a DSC Configuration run
503 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
504 | del $StagingPath\\*.mof
505 | "
506 | 
507 |         expect(script).to eq(expect_script)
508 |       end
509 | 
510 |       it "should allow flags as arguments to the generated Powershell runner" do
511 |         root_config.configuration_params = {"-FooFlag" => nil, "-BarFlag" => nil, "-FooParam" => "FooVal"}
512 |         script = subject.generate_dsc_runner_script
513 | 
514 |         expect_script = "#
515 | # DSC Runner.
516 | #
517 | # Bootstraps the DSC environment, sets up configuration data
518 | # and runs the DSC Configuration.
519 | #
520 | #
521 | 
522 | # Set the local PowerShell Module environment path
523 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
524 | 
525 | echo \"Adding to path: $absoluteModulePaths\"
526 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
527 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
528 | 
529 | 
530 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
531 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
532 | echo \"\"
533 | echo \"Running Configuration file: ${script}\"
534 | 
535 | # Generate the MOF file, only if a MOF path not already provided.
536 | # Import the Manifest
537 | . $script
538 | 
539 | cd \"/tmp/vagrant-dsc-1\"
540 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
541 | MyWebsite -OutputPath $StagingPath -FooFlag -BarFlag -FooParam \"FooVal\"
542 | 
543 | # Start a DSC Configuration run
544 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
545 | del $StagingPath\\*.mof
546 | "
547 | 
548 |         expect(script).to eq(expect_script)
549 |       end
550 |     end
551 | 
552 |     context "with a MOF file specified" do
553 |       it "should generate a script that does not generate a new MOF" do
554 |         root_config.configuration_params = {}
555 |         root_config.mof_path = "staging"
556 |         script = subject.generate_dsc_runner_script
557 | 
558 |         expect_script = "#
559 | # DSC Runner.
560 | #
561 | # Bootstraps the DSC environment, sets up configuration data
562 | # and runs the DSC Configuration.
563 | #
564 | #
565 | 
566 | # Set the local PowerShell Module environment path
567 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
568 | 
569 | echo \"Adding to path: $absoluteModulePaths\"
570 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
571 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
572 | 
573 | 
574 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
575 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
576 | echo \"\"
577 | echo \"Running Configuration file: ${script}\"
578 | 
579 | # Generate the MOF file, only if a MOF path not already provided.
580 | $StagingPath = \"staging\"
581 | 
582 | # Start a DSC Configuration run
583 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
584 | del $StagingPath\\*.mof
585 | "
586 | 
587 |         expect(script).to eq(expect_script)
588 |       end
589 |     end
590 | 
591 |     context "with -ConfigurationData" do
592 |       before do
593 |         # Prevent counters messing with output in tests
594 |         Vagrant::Util::Counter.class_eval do
595 |           def get_and_update_counter(name=nil) 1 end
596 |         end
597 | 
598 |         allow(machine).to receive(:root_config).and_return(root_config)
599 |         root_config.configuration_file = configuration_file
600 |         root_config.configuration_data_file = configuration_data_file
601 |         allow(machine).to receive_messages(config: root_config, env: env)
602 |         root_config.module_path = module_path
603 |         root_config.configuration_file = configuration_file
604 |         root_config.finalize!
605 |         root_config.validate(machine)
606 |         subject.configure(root_config)
607 | 
608 |       end
609 | 
610 |       it "should pass in the location of" do
611 |         script = subject.generate_dsc_runner_script
612 |         expect_script = "#
613 | # DSC Runner.
614 | #
615 | # Bootstraps the DSC environment, sets up configuration data
616 | # and runs the DSC Configuration.
617 | #
618 | #
619 | 
620 | # Set the local PowerShell Module environment path
621 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
622 | 
623 | echo \"Adding to path: $absoluteModulePaths\"
624 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
625 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
626 | 
627 | 
628 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
629 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
630 | echo \"\"
631 | echo \"Running Configuration file: ${script}\"
632 | 
633 | # Generate the MOF file, only if a MOF path not already provided.
634 | # Import the Manifest
635 | . $script
636 | 
637 | cd \"/tmp/vagrant-dsc-1\"
638 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
639 | $Config = $(iex (Get-Content (Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyConfig.psd1\" -Resolve) | Out-String))
640 | MyWebsite -OutputPath $StagingPath  -ConfigurationData $Config
641 | 
642 | # Start a DSC Configuration run
643 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
644 | del $StagingPath\\*.mof
645 | "
646 | 
647 |         expect(script).to eq(expect_script)
648 |       end
649 |     end
650 | 
651 |     context "with module_install" do
652 |       it "should generate a valid powershell command" do
653 |         root_config.module_install = ["xNetworking", "xSQLServer"]
654 | 
655 |         script = subject.generate_dsc_runner_script
656 |         expect_script = "#
657 | # DSC Runner.
658 | #
659 | # Bootstraps the DSC environment, sets up configuration data
660 | # and runs the DSC Configuration.
661 | #
662 | #
663 | 
664 | # Set the local PowerShell Module environment path
665 | $absoluteModulePaths = [string]::Join(\";\", (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { $_ | Resolve-Path }))
666 | 
667 | echo \"Adding to path: $absoluteModulePaths\"
668 | $env:PSModulePath=\"$absoluteModulePaths;${env:PSModulePath}\"
669 | (\"/tmp/vagrant-dsc-1/modules-0;/tmp/vagrant-dsc-1/modules-1\".Split(\";\") | ForEach-Object { gci -Recurse  $_ | ForEach-Object { Unblock-File  $_.FullName} })
670 | 
671 | Write-Host \"Ensure Modules\"
672 | Get-PackageProvider -Name NuGet -ListAvailable -ErrorAction SilentlyContinue -ErrorVariable NuGetError | Out-Null
673 | if ($NuGetError) {
674 |     Write-Host \"Install Package Provider Nuget\"
675 |     Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force | Out-Null
676 | }
677 | if ((Get-PSRepository -Name PSGallery).InstallationPolicy -ne \"Trusted\") {
678 |     Set-PSRepository -Name PSGallery -InstallationPolicy \"Trusted\"
679 | }
680 | # Install-Module only installs if the module is not already installed
681 | \"xNetworking;xSQLServer\".Split(\";\") | foreach { Install-Module $_ }
682 | 
683 | $script = $(Join-Path \"/tmp/vagrant-dsc-1\" \"manifests/MyWebsite.ps1\" -Resolve)
684 | echo \"PSModulePath Configured: ${env:PSModulePath}\"
685 | echo \"\"
686 | echo \"Running Configuration file: ${script}\"
687 | 
688 | # Generate the MOF file, only if a MOF path not already provided.
689 | # Import the Manifest
690 | . $script
691 | 
692 | cd \"/tmp/vagrant-dsc-1\"
693 | $StagingPath = $(Join-Path \"/tmp/vagrant-dsc-1\" \"staging\")
694 | MyWebsite -OutputPath $StagingPath 
695 | 
696 | # Start a DSC Configuration run
697 | Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
698 | del $StagingPath\\*.mof
699 | "
700 | 
701 |         expect(script).to eq(expect_script)
702 |       end
703 |     end
704 | 
705 |   end
706 | 
707 |   describe "write DSC Runner script" do
708 |     it "should upload the customised DSC runner to the guest" do
709 |       script = "myscript"
710 |       path = "/local/runner/path"
711 |       guest_path = "c:/tmp/vagrant-dsc-runner.ps1"
712 |       allow(machine).to receive_messages(config: root_config, env: env, communicate: communicator)
713 |       file = double("file")
714 |       allow(file).to receive(:path).and_return(path)
715 |       allow(Tempfile).to receive(:new) { file }
716 |       expect(file).to receive(:write).with(script)
717 |       expect(file).to receive(:fsync)
718 |       expect(file).to receive(:close).exactly(2).times
719 |       expect(file).to receive(:unlink)
720 |       expect(communicator).to receive(:upload).with(path, guest_path)
721 |       res = subject.write_dsc_runner_script(script)
722 |       expect(res.to_s).to eq(guest_path)
723 |     end
724 |   end
725 | 
726 |   describe "Apply DSC" do
727 |     it "should invoke the DSC Runner and notify the User of provisioning status" do
728 |       allow(communicator).to receive(:shell).and_return(shell)
729 |       allow(machine).to receive(:communicate).and_return(communicator)
730 |       expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-dsc-runner.ps1").and_yield(:stdout, "provisioned!")
731 |       root_config.configuration_file = configuration_file
732 |       expect(ui).to receive(:info).with("\"Running DSC Provisioner with manifests/MyWebsite.ps1...\"")
733 |       expect(ui).to receive(:info).with("provisioned!", {color: :green, prefix: false}).once
734 | 
735 |       subject.run_dsc_apply
736 |     end
737 | 
738 |     it "should show error output in red" do
739 |       allow(machine).to receive(:communicate).and_return(communicator)
740 |       allow(communicator).to receive(:shell).and_return(shell)
741 | 
742 |       root_config.configuration_file = configuration_file
743 |       expect(ui).to receive(:info).with("\"Running DSC Provisioner with manifests/MyWebsite.ps1...\"")
744 |       expect(ui).to receive(:info).with("not provisioned!", {color: :red, prefix: false}).once
745 |       expect(shell).to receive(:powershell).with("powershell -ExecutionPolicy Bypass -OutputFormat Text -file c:/tmp/vagrant-dsc-runner.ps1").and_yield(:stderr, "not provisioned!")
746 | 
747 |       subject.run_dsc_apply
748 |     end
749 | 
750 |         it "should format DSC Output correct" do
751 |       allow(machine).to receive(:communicate).and_return(communicator)
752 |       allow(communicator).to receive(:shell).and_return(shell)
753 | 
754 |       root_config.configuration_file = configuration_file
755 |       expect(ui).not_to receive(:info).with(/\r\n/, any_args)
756 |       expect(ui).not_to receive(:info).with(/^\n/, any_args)
757 |       expect(ui).not_to receive(:info).with(/\n$/, any_args)
758 |       expect(shell).to receive(:powershell)
759 |         .and_yield(:stout, "PSModulePath Configured: C:\\Users\\vagrant\\Documents\\WindowsPowerShell\\Modules;C:\\Program Files\\WindowsPowerShell\\Modules;C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\Modules")
760 |         .and_yield(:stout, "\r\nRunning Configuration file: C:\\tmp\\vagrant-dsc-3\\manifests\\Reboot.ps1\r\n")
761 |         .and_yield(:stout, "\r\n    Directory: C:\\tmp\\vagrant-dsc-3\\staging\r\n\r\n\r\nMode                LastWriteTime         Length Name                                                                  \r\n----                -------------         ------ ----                                 \r\n-a----       10/17/2016   7:09 AM           3420 localhost.mof                                                         \r\n")
762 |         .and_yield(:stout, "VERBOSE: Perform operation 'Invoke CimMethod' with following parameters, ''methodName' = \r\nSendConfigurationApply,'className' = MSFT_DSCLocalConfigurationManager,'namespaceName' = \r\nroot/Microsoft/Windows/DesiredStateConfiguration'.")
763 |         .and_yield(:stout, "VERBOSE: An LCM method call arrived from computer WIN-QRTPA0OO7EK with user sid \r\nS-1-5-21-678342207-3002680417-1007590926-1000.\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Start  Set      ]\n")
764 |         .and_yield(:stout, "VERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Start  Resource ]  [[Script]Reboot]")
765 |         .and_yield(:stout, "\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Start  Test     ]  [[Script]Reboot]\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ End    Test     ]  [[Script]Reboot]  in 0.0000 seconds.\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Skip   Set      ]  [[Script]Reboot]\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ End    Resource ]  [[Script]Reboot]\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Start  Resource ]  [[Script]Error]\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ Start  Test     ]  [[Script]Error]\nVERBOSE: [WIN-QRTPA0OO7EK]: LCM:  [ End    Test     ]  [[Script]Error]  in 0.0000 seconds.\n")
766 |         .and_yield(:stderr, "PowerShell DSC resource MSFT_ScriptResource  failed to execute Test-TargetResource functionality with error message: \r\n")
767 |         .and_yield(:stderr, "\nVERBOSE: Operation 'Invoke CimMethod' complete.\nVERBOSE: Time taken for configuration job to complete is 0.198 seconds\n\r\n\r\n")
768 | 
769 |       subject.run_dsc_apply
770 |     end
771 |   end
772 | end
773 | 


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