vagrant-dsc 0.0.1.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f557e67cafe5c89fb6f203f66d638247f087cce7
+  data.tar.gz: b56ff50eea0ab89a8445b9c062e467fd57803c7b
+SHA512:
+  metadata.gz: 0fb75aa00d69bb332d73d45b3fa8d714fcbf7bd21dda120fbf22578dd8f706fe1324343db3a94094aff47d9e9b09f5d1dd9e17575180a0552cc9ba9e0aeeab00
+  data.tar.gz: e87885d268d76c03ce585f0976a43ba3b382ae12847a9af8c9834e6e4050ea92f54807048dd664c393da6fab91e988047308e9cd2f6660bd38282319f565c35b

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.vagrant
+.idea

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+before_install:
+- rvm @global do gem uninstall bundler --all --executables
+- gem uninstall bundler --all --executables
+- gem install bundler --version '< 1.7.0'
+rvm:
+- 2.0.0
+- 2.1.0
+- ruby-head
+matrix:
+  allow_failures:
+  - rvm: ruby-head
+  fast_finish: true
+env:
+  matrix:
+  - VAGRANT_VERSION=v1.6.5
+  global:
+    secure: d34dSoYsh9C9tCgAeKp3TIYdxPlrGh1j+x01Igg7Ku0rmmv0f1+NSZOcSpgbf5daXFk1i5mQrRcYjIVOclGAlCXM7IKWfDyefstmYl+2+Hjv4LGJHQNvBTz02MerfKlUef2HMAt3HJsNvwhqvIVrHetC6ZeSaFtupWqhuXWgREQ=
+script: bundle exec rake test:unit

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-dsc.gemspec
+gemspec
+
+group :development do
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-dsc", path: "."
+end

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,67 @@
+# Vagrant DSC Plugin
+
+[Desired State Configuration](http://technet.microsoft.com/en-au/library/dn249912.aspx) provisioning plugin for Vagrant, enabling you to quickly configure & bootstrap a Windows Virtual Machine in a repeatable, reliable fashion.
+
+.NET Devs - no more excuses...
+
+> But it works on my machine!?
+
+...is a thing of the past
+
+## Installation
+
+```vagrant plugin install vagrant-dsc```
+
+## Usage
+
+In your Vagrantfile, add the following plugin:
+
+```ruby
+  config.vm.provision "dsc" do |dsc|
+    # The (Vagrantfile) relative path(s) to any folder containing DSC Resources
+    dsc.manifests_path = ["manifests", "other_manifests"]
+
+    # The path relative to `dsc.manifests_path` pointing to the Configuration file
+    # Defaults to `default.ps1`
+    dsc.manifest_file  = "MyWebsite.ps1"
+
+    # The Configuration Command to run. Assumed to be the same as the `dsc.manifest_file`
+    # (sans extension) if not provided. In this case it would default to 'MyWebsite'
+    dsc.command_name = "MyCustomCommandNameForWebsite"
+
+    #
+    dsc.parameters
+  end
+```
+
+## Features
+
+*
+
+### Supported Environments
+
+Currently the plugin only supports modern Windows environments with DSC installed (Windows 8.1+, Windows Server 2012 R2+ are safe bets).
+The plugin works on older platforms that have a later version of .NET (4.5) and the WMF 4.0 installed.
+
+As a general guide, configuring your Windows Server
+
+From the [DSC Book](https://onedrive.live.com/view.aspx?cid=7F868AA697B937FE&resid=7F868AA697B937FE!156&app=Word):
+
+> **DSC Overview and Requirements**
+> 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.
+> 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.
+> 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.
+
+We may consider automatically installing and configuring DSC in a future release of the plugin.
+
+## Uninistallation
+
+```vagrant plugin uninstall vagrant-dsc```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/vagrant-dsc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Squash commits & push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+task :default => [:test, :quality]
+# Remove 'install' task as the gem is installed to Vagrant, not to system
+Rake::Task[:install].clear
+namespace :test do
+  RSpec::Core::RakeTask.new('unit') do |task|
+    task.pattern = 'spec/**/*_spec.rb'
+  end
+end
+desc "Run all tests"
+task :test => ['test:unit']
+task :spec => :test

data/development/Vagrantfile

@@ -0,0 +1,86 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "win-dev"
+
+  config.vm.guest = :windows
+  config.vm.communicator = "winrm"
+
+  config.vm.network :forwarded_port, guest: 3389, host: 3389
+  config.vm.network :forwarded_port, guest: 5985, host: 5985, id: "winrm", auto_correct: true
+  config.vm.network :forwarded_port, guest: 80, host: 8000 # Port forward for IIS
+
+  config.vm.provider "virtualbox" do |v|
+    v.gui = true
+  end
+
+  $script = <<SCRIPT
+#
+# Script that gets executed on the remote machine
+#
+
+function Write-BootstrapProgress
+{
+    param($message)
+    Write-Host "        ${message}"
+}
+
+# Install Choco if not already installed
+
+if ( (Get-Command "choco" -errorAction SilentlyContinue) ) {
+    Write-BootstrapProgress "Chocolatey already installed. Skipping."
+} else {
+    Write-BootstrapProgress "Installing Chocolatey"
+    $wc=new-object net.webclient; $wp=[system.net.WebProxy]::GetDefaultProxy(); $wp.UseDefaultCredentials=$true; $wc.Proxy=$wp; iex ($wc.DownloadString('https://chocolatey.org/install.ps1'))
+    # Add to path
+    $env:Path = $env:Path + ";C:\ProgramData\chocolatey\bin"
+    [Environment]::SetEnvironmentVariable( "Path", $env:Path, [System.EnvironmentVariableTarget]::Machine )
+}
+
+Write-BootstrapProgress "Installing required software"
+if ( -Not (Get-Command "Install-Module" -errorAction SilentlyContinue) ) {
+    Write-BootstrapProgress "Installing PSGet"
+    (new-object Net.WebClient).DownloadString("http://psget.net/GetPsGet.ps1") | iex
+}
+Install-Module Posh-Git
+
+Write-BootstrapProgress "Installing required packages"
+$packages = @(
+    "git.commandline"
+    "git"
+    "seek-dsc"
+    "NuGet.CommandLine"
+    "invokemsbuild"
+)
+
+Write-BootstrapProgress "Packages installed"
+SCRIPT
+
+  # First pre-configure the machine with required software
+  config.vm.provision "shell", inline: $script
+
+  config.vm.provision "dsc" do |dsc|
+    # The (Vagrantfile) relative path(s) to any folder containing DSC Resources
+    dsc.module_path = ["manifests", "modules"]
+
+    # The path relative to `dsc.manifests_path` pointing to the Configuration file
+    dsc.manifest_file  = "manifests/ContosoWebsite.ps1"
+
+    # The Configuration Command to run. Assumed to be the same as the `dsc.manifest_file`
+    # (sans extension) if not provided.
+    # dsc.command_name = "ContosoWebsite"
+
+    # Commandline arguments to the Configuration run
+    dsc.configuration_parameters = {}
+    dsc.configuration_parameters[:machineName] = "localhost"
+  end
+end

data/development/manifests/ContosoWebsite.ps1

@@ -0,0 +1,17 @@
+Configuration ContosoWebsite
+{
+  param ($MachineName)
+
+  Node $MachineName
+  {
+    #Install the IIS Role
+    File website
+    {
+      Ensure = "Present"
+      Type = "Directory"
+      DestinationPath = "c:\mywebroot"
+    }
+  }
+}
+
+Write-Output "Hello from DSC Provisioner: Config file"

data/lib/vagrant-dsc/config.rb

@@ -0,0 +1,108 @@
+require "vagrant/util/counter"
+require "log4r"
+
+module VagrantPlugins
+  module DSC
+    class Config < Vagrant.plugin("2", :config)
+      extend Vagrant::Util::Counter
+
+      attr_accessor :facter
+      attr_accessor :mof_file
+      attr_accessor :manifest_file
+      attr_accessor :manifests_path
+      attr_accessor :configuration_name
+      attr_accessor :module_path
+      attr_accessor :options
+      attr_accessor :synced_folder_type
+      attr_accessor :temp_dir
+      attr_accessor :working_directory
+
+      def initialize
+        super
+
+        @manifest_file      = UNSET_VALUE
+        @manifests_path     = UNSET_VALUE
+        @configuration_name = UNSET_VALUE
+        @mof_file           = UNSET_VALUE
+        @module_path        = UNSET_VALUE
+        @options            = []
+        @facter             = {}
+        @synced_folder_type = UNSET_VALUE
+        @temp_dir           = UNSET_VALUE
+        @working_directory  = UNSET_VALUE
+
+        @logger = Log4r::Logger.new("vagrant::vagrant_dsc")
+      end
+
+      def merge(other)
+        super.tap do |result|
+          result.facter  = @facter.merge(other.facter)
+        end
+      end
+
+      def finalize!
+        super
+
+        @manifest_file      = "default.ps1" if @manifest_file == UNSET_VALUE
+        @module_path        = nil if @module_path == UNSET_VALUE
+        @synced_folder_type = nil if @synced_folder_type == UNSET_VALUE
+        @temp_dir           = nil if @temp_dir == UNSET_VALUE
+        @mof_file           = nil if @mof_file == UNSET_VALUE
+        @working_directory  = nil if @working_directory == UNSET_VALUE
+        @configuration_name = File.basename(@manifest_file, File.extname(@manifest_file)) if @configuration_name == UNSET_VALUE
+        @manifests_path     = File.dirname(@manifest_file)
+
+        # Set a default temp dir that has an increasing counter so
+        # that multiple DSC definitions won't overwrite each other
+        if !@temp_dir
+          counter   = self.class.get_and_update_counter(:dsc_config)
+          @temp_dir = "/tmp/vagrant-dsc-#{counter}"
+        end
+      end
+
+      # Returns the module paths as an array of paths expanded relative to the
+      # root path.
+      def expanded_module_paths(root_path)
+        return [] if !module_path
+
+        # Get all the paths and expand them relative to the root path, returning
+        # the array of expanded paths
+        paths = module_path
+        paths = [paths] if !paths.is_a?(Array)
+        paths.map do |path|
+          Pathname.new(path).expand_path(root_path)
+        end
+      end
+
+      #
+      # Validate configuration
+      #
+      def validate(machine)
+        @logger.info("==> Configurin' DSC man!")
+        errors = _detected_errors
+
+        # Calculate the manifests and module paths based on env
+        this_expanded_module_paths = expanded_module_paths(machine.env.root_path)
+
+        # Manifest file validation
+
+        if manifests_path[0].to_sym == :host
+          expanded_path = Pathname.new(manifests_path[1]).
+              expand_path(machine.env.root_path)
+          if !expanded_path.directory?
+            errors << I18n.t("vagrant_dsc.errors.manifests_path_missing",
+                             path: expanded_path.to_s)
+          else
+            expanded_manifest_file = expanded_path.join(manifest_file)
+            if !expanded_manifest_file.file? && !expanded_manifest_file.directory?
+              errors << I18n.t("vagrant_dsc.errors.manifest_missing",
+                               manifest: expanded_manifest_file.to_s)
+            end
+          end
+        end
+
+        { "dsc provisioner" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-dsc/locales/en.yml

@@ -0,0 +1,32 @@
+en:
+  vagrant_dsc:
+    already_status: |-
+      The machine is already %{status}.
+
+    running_dsc: |-
+      "Running DSC Provisioner with %{manifest}..."
+
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
+
+    config:
+      access_key_id_required: |-
+        An access key ID must be specified via "access_key_id"
+
+    errors:
+      missing_shared_folders: |-
+        Shared folders not properly configured. This is generally resolved by a 'vagrant halt && vagrant up'
+      unsupported_os: |-
+        Vagrant DSC does not work
+      dsc_not_detected: |-
+        Unable to detect a working DSC environment. Please ensure powershell v4+
+        is installed, including WMF 4+.
+      dsc_incorrect_powershell_version: |-
+        Powershell version 4 or greater not installed. Please ensure powershell v4+ is installed, including WMF 4+.
+      module_path_missing: |-
+        "Path to DSC Modules does not exist: %{path}"
+      manifests_path_missing: |-
+        "Path to DSC Manifest folder does not exist: %{path}"
+      manifest_missing: |-
+        "Path to DSC Manifest does not exist: %{manifest}"

data/lib/vagrant-dsc/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module DSC
+    class Plugin < Vagrant.plugin("2")
+      name "DSC"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      DSC either using a local `DSC` Configuration or a DSC server.
+      DESC
+
+      config(:dsc, :provisioner) do
+        require_relative 'config'
+        Config
+      end
+
+      provisioner(:dsc) do
+        require_relative 'provisioner'
+        Provisioner
+      end
+    end
+  end
+end

data/lib/vagrant-dsc/powershell/configure_dsc.ps1

@@ -0,0 +1,13 @@
+# Sets up DSC
+echo 'Setting up DSC components'
+
+$ChocoInstallPathOld = "$env:SystemDrive\Chocolatey\bin"
+$ChocoInstallPath = "$env:SystemDrive\ProgramData\Chocolatey\bin"
+
+# Install chocolatey
+if ( !(Get-Command "choco") -and !(Test-Path $ChocoInstallPath)) {
+  iex ((new-object net.webclient).DownloadString('http://chocolatey.org/install.ps1'))
+}
+
+choco install DotNet4.5
+choco install powershell4

data/lib/vagrant-dsc/provisioner.rb

@@ -0,0 +1,192 @@
+require "log4r"
+require 'erb'
+
+module VagrantPlugins
+  module DSC
+    class DSCError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant_dsc.errors")
+      I18n.load_path << File.expand_path("locales/en.yml", File.dirname(__FILE__))
+    end
+
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      POWERSHELL_VERSION = 5
+      DSC_GUEST_RUNNER_PATH = "c:/tmp/vagrant-dsc-runner.ps1"
+
+      def initialize(machine, config)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::provisioners::dsc")
+      end
+
+      def configure(root_config)
+        @logger.info("==> Configuring DSC man!")
+
+        # Calculate the paths we're going to use based on the environment
+        root_path = @machine.env.root_path
+        @expanded_module_paths   = @config.expanded_module_paths(root_path)
+        @manifest_file           = File.join(manifests_guest_path, @config.manifest_file)
+
+        # Setup the module paths
+        @module_paths = []
+        @expanded_module_paths.each_with_index do |path, i|
+          @module_paths << [path, File.join(config.temp_dir, "modules-#{i}")]
+        end
+
+        folder_opts = {}
+        folder_opts[:type] = @config.synced_folder_type if @config.synced_folder_type
+        folder_opts[:owner] = "root" if !@config.synced_folder_type
+
+        # Share the manifests directory with the guest
+        @logger.info("==> Sharing manifest #{File.expand_path(@config.manifests_path, root_path)} | #{manifests_guest_path} | #{folder_opts}")
+        root_config.vm.synced_folder(
+          File.expand_path(@config.manifests_path, root_path),
+          manifests_guest_path, folder_opts)
+
+        # Share the module paths
+        @module_paths.each do |from, to|
+          @logger.info("==> Sharing module folders #{from} | #{to}")
+          root_config.vm.synced_folder(from, to, folder_opts)
+        end
+      end
+
+      def provision
+        @logger.info("==> Provisioning DSC man! #{Vagrant.source_root}")
+
+        # If the machine has a wait for reboot functionality, then
+        # do that (primarily Windows)
+        if @machine.guest.capability?(:wait_for_reboot)
+          @machine.guest.capability(:wait_for_reboot)
+        end
+
+        # Check that the shared folders are properly shared
+        check = []
+        check << manifests_guest_path
+        @module_paths.each do |host_path, guest_path|
+          check << guest_path
+        end
+
+        # Make sure the temporary directory is properly set up
+        @machine.communicate.tap do |comm|
+          comm.sudo("mkdir -p #{config.temp_dir}")
+          comm.sudo("chmod 0777 #{config.temp_dir}")
+        end
+
+        verify_shared_folders(check)
+
+        verify_dsc
+
+        generate_dsc_runner_script
+
+        run_dsc_apply
+
+      end
+
+      def manifests_guest_path
+          File.join(config.temp_dir, config.manifests_path)
+      end
+
+      def verify_dsc
+        verify_binary("Start-DscConfiguration")
+
+        # Confirm WMF 4.0+ in $PSVersionTable
+        @machine.communicate.test(
+            "(($PSVersionTable | ConvertTo-json | ConvertFrom-Json).PSVersion.Major) -ge #{POWERSHELL_VERSION} ",
+            error_class: DSCError,
+            error_key: :dsc_incorrect_powershell_version )
+      end
+
+      def verify_binary(binary)
+        @machine.communicate.sudo(
+          "which #{binary}",
+          error_class: DSCError,
+          error_key: :dsc_not_detected,
+          binary: binary)
+      end
+
+      # Install and Configure DSC where possible.
+      #
+      def install_dsc
+
+        # Ensure .NET 4.5 installed
+
+        # Ensure WMF 4.0 is installed
+
+      end
+
+      # Generates a Powershell DSC runner script from an ERB template
+      def generate_dsc_runner_script
+        path = File.expand_path("../templates/runner.ps1", __FILE__)
+        script = Vagrant::Util::TemplateRenderer.render(path, options: {
+            config: config,
+            module_paths: @module_paths,
+            manifest_file: config.manifest_file,
+            configuration_name: config.configuration_name,
+            temp_path: config.temp_dir,
+            parameters: config.parameters.map { |k,v|}.join,
+        })
+        guest_script_path = DSC_GUEST_RUNNER_PATH
+        file = Tempfile.new(["vagrant-dsc-runner", "ps1"])
+        begin
+          file.write(script)
+          file.fsync
+          file.close
+          @machine.communicate.upload(file.path, guest_script_path)
+        ensure
+          file.close
+          file.unlink
+        end
+        guest_script_path
+      end
+
+      def run_dsc_apply
+
+        # Set up Configuration arguments (hostname, manifest/module location, error levels ...)
+
+          # Where are the modules?
+
+          # Where is the manifest
+
+        # Setup $env:PSModulePath for execution env.
+
+        # Integrator -ConfigurationData "$SetupPath\Configuration\Development.psd1" -OutputPath $StagingPath -BasePath $AppBasePath
+
+        # TODO: Get a counter in here in case of multiple runs
+
+        # Apply configuration/parameters to DSC Runner
+
+        # Import starting point configuration into scope
+
+        command = ".\"#{DSC_GUEST_RUNNER_PATH}\""
+
+        @machine.ui.info(I18n.t(
+          "vagrant_dsc.running_dsc",
+          manifest: config.manifest_file))
+
+        opts = {
+          elevated: true,
+          error_key: :ssh_bad_exit_status_muted,
+          good_exit: [0,2],
+        }
+
+        @machine.communicate.sudo(command, opts) do |type, data|
+          if !data.chomp.empty?
+            @machine.ui.info(data.chomp)
+          end
+        end
+      end
+
+      def verify_shared_folders(folders)
+        folders.each do |folder|
+          @logger.info("Checking for shared folder: #{folder}")
+          if !@machine.communicate.test("test -d #{folder}", sudo: true)
+            raise DSCError, :missing_shared_folders
+          end
+        end
+      end
+
+      def windows?
+        @machine.config.vm.communicator == :winrm
+      end
+    end
+  end
+end

data/lib/vagrant-dsc/templates/runner.ps1.erb

@@ -0,0 +1,27 @@
+#
+# DSC Runner Script.
+# Bootstraps the DSC environment, configuration and runs the DSC Configuration.
+#
+
+# Set the local PowerShell module environment path
+<% options[:module_paths].each do |host, guest| %>
+    echo "Adding to path: <%= guest %>"
+    $env:PSModulePath="<%= guest %>;${env:PSModulePath}"
+<% end %>
+
+echo "PSModulePath Configured: ${env:PSModulePath}"
+echo "Running Configuration file: <%= options[:manifest_file_path] %>"
+
+# Import the Manifest
+. $(Join-Path "<%= options[:temp_path] %>" "<%= options[:manifest_file] %>")
+
+# Generate the MOF file
+cd "<%= options[:temp_path] %>"
+$StagingPath = $(Join-Path "<%= options[:temp_path] %>" "staging")
+<%= options[:configuration_name] %> -MachineName "localhost" -OutputPath $StagingPath <%= options[:configuration_parameters] %>
+
+# Start a DSC Configuration run
+Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath
+
+# Cleanup
+del -Path $StagingPath -Recurse

data/lib/vagrant-dsc/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module Dsc
+    VERSION = "0.0.1.beta"
+  end
+end