vagrant-dsc 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1dd5efd1b9d993187d7cf8d74f014de2744618dd
-  data.tar.gz: 1e9aefbc93396c81c5aedb56d44aa19db81033de
+  metadata.gz: c8ec166dab0cf1c326f7d0f943abcee534574d68
+  data.tar.gz: aad0961c447ebf11921c64c920d43463fb2410b5
 SHA512:
-  metadata.gz: 3522383b0a55be34bf4dc30b5ea3ce64d1a4db84a3eca3e3e83ad6bce93f8188a03b19e7bca8886c27c7a84f561dd774071cf302574f2b78508c0d202a8d22da
-  data.tar.gz: 033aa03d21640d320f5604e323d22d3d22025e203b10db6deaca764a0248324c9f875761014b5261a3991cc528a878a041ba6af8df8aba0b08de28261eb078d5
+  metadata.gz: 16b406fbc437d601f40536c687efac1536588655a4813a3592ebfc9f19f0496cfaa1750a87b640d8ba5e429e68e453fd07d45774c1817408e1650b0ad3eac0bb
+  data.tar.gz: 603e019f5b4444ef240733f8a8eb417f3ed003a3ed394fe64212218736936c5549b8401409d47ea7f901a962d119694411758c9920b26504520631bf1027662d

data/README.md

@@ -1,6 +1,10 @@
 # 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.
+[![Build Status](https://travis-ci.org/mefellows/vagrant-dsc.svg)](https://travis-ci.org/mefellows/vagrant-dsc)
+[![Coverage Status](https://coveralls.io/repos/mefellows/vagrant-dsc/badge.png)](https://coveralls.io/r/mefellows/vagrant-dsc)
+[![Gem Version](https://badge.fury.io/rb/vagrant-dsc.svg)](http://badge.fury.io/rb/vagrant-dsc)
+
+[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 - the Vagrant way.
 
 .NET Devs - no more excuses...
 
@@ -14,29 +18,59 @@
 
 ## Usage
 
-In your Vagrantfile, add the following plugin:
+In your Vagrantfile, add the following plugin and configure to your needs:
 
 ```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"
+    dsc.configuration_file  = "MyWebsite.ps1"
+
+    # The Configuration Command to run. Assumed to be the same as the `dsc.configuration_file`
+    # (sans extension) if not provided.
+    dsc.configuration_name = "MyWebsite"
+
+    # Commandline arguments to the Configuration run
+    # Set of Parameters to pass to the DSC Configuration.
+    #
+    # To pass in flags, simply set the value to `nil`
+    dsc.configuration_params = {"machineName => "localhost", "-EnableDebug" => nil}
+
+    # Relative path to a folder containing a pre-generated MOF file.
+    #
+    # Path is relative to the folder containing the Vagrantfile.
+    #dsc.mof_path = "mof_output"
+
+    # Relative path to the folder containing the root Configuration manifest file.
+    # Defaults to 'manifests'.
+    #
+    # Path is relative to the folder containing the Vagrantfile.
+    # dsc.manifests_path = "manifests"
 
-    # 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"
+    # Set of module paths relative to the Vagrantfile dir.
+    #
+    # These paths are added to the DSC Configuration running
+    # environment to enable local modules to be addressed.
+    #
+    # @return [Array] Set of relative module paths.
+    #dsc.module_path = ["manifests", "modules"]
 
+    # The type of synced folders to use when sharing the data
+    # required for the provisioner to work properly.
     #
-    dsc.parameters
+    # By default this will use the default synced folder type.
+    # For example, you can set this to "nfs" to use NFS synced folders.
+    #dsc.synced_folder_type = ""
+
+    # Temporary working directory on the guest machine.
+    #dsc.temp_dir = "/tmp/vagrant-dsc"
   end
 ```
 
-## Features
+## Roadmap
 
-*
+* Support DSC Pull Server provisioning
+* Test (dry-run) a DSC Configuration Run with 'vagrant vagrant-dsc test'
+* Support for non-Windows environments
 
 ### Supported Environments
 

data/development/Vagrantfile

@@ -73,14 +73,43 @@ SCRIPT
     dsc.module_path = ["manifests", "modules"]
 
     # The path relative to `dsc.manifests_path` pointing to the Configuration file
-    dsc.manifest_file  = "manifests/ContosoWebsite.ps1"
+    dsc.configuration_file  = "manifests/MyWebsite.ps1"
 
-    # The Configuration Command to run. Assumed to be the same as the `dsc.manifest_file`
+    # The Configuration Command to run. Assumed to be the same as the `dsc.configuration_file`
     # (sans extension) if not provided.
-    # dsc.command_name = "ContosoWebsite"
+    dsc.configuration_name = "MyWebsite"
 
     # Commandline arguments to the Configuration run
-    dsc.configuration_parameters = {}
-    dsc.configuration_parameters[:machineName] = "localhost"
+    # Set of Parameters to pass to the DSC Configuration.
+    dsc.configuration_params = {[:machineName] => "localhost"}
+
+    # Relative path to a pre-generated MOF file.
+    #
+    # Path is relative to the folder containing the Vagrantfile.
+    #dsc.mof_file = "localhost.mof"
+
+    # Relative path to the folder containing the root Configuration manifest file.
+    # Defaults to 'manifests'.
+    #
+    # Path is relative to the folder containing the Vagrantfile.
+    # dsc.manifests_path = "manifests"
+
+    # Set of module paths relative to the Vagrantfile dir.
+    #
+    # These paths are added to the DSC Configuration running
+    # environment to enable local modules to be addressed.
+    #
+    # @return [Array] Set of relative module paths.
+    #dsc.module_path = []
+
+    # The type of synced folders to use when sharing the data
+    # required for the provisioner to work properly.
+    #
+    # By default this will use the default synced folder type.
+    # For example, you can set this to "nfs" to use NFS synced folders.
+    #dsc.synced_folder_type = ""
+
+    # Temporary working directory on the guest machine.
+    #dsc.temp_dir = "/tmp/vagrant-dsc"
   end
 end

data/development/manifests/{ContosoWebsite.ps1 → MyWebsite.ps1}

@@ -1,4 +1,4 @@
-Configuration ContosoWebsite
+Configuration MyWebsite
 {
   param ($MachineName)
 

data/lib/vagrant-dsc/config.rb

@@ -3,54 +3,96 @@ require "log4r"
 
 module VagrantPlugins
   module DSC
+    # The "Configuration" represents a configuration of how the DSC
+    # provisioner should behave: data directories, working directory,
+    # DSC Manifests etc.
     class Config < Vagrant.plugin("2", :config)
       extend Vagrant::Util::Counter
 
-      attr_accessor :facter
-      attr_accessor :mof_file
-      attr_accessor :manifest_file
+      # Set of Parameters to pass to the DSC Configuration.
+      #
+      # @return [Hash] Set of k/v parameters to pass to DSC.
+      attr_accessor :configuration_params
+
+      # Relative path to a folder, containing the pre-generated MOF file.
+      #
+      # Path is relative to the folder containing the Vagrantfile.
+      attr_accessor :mof_path
+
+      # Relative path to the DSC Configuration file.
+      #
+      # Path is relative to the folder containing the Vagrantfile.
+      attr_accessor :configuration_file
+
+      # Relative path to the folder containing the root Configuration manifest file.
+      # Defaults to 'manifests'.
+      #
+      # Path is relative to the folder containing the Vagrantfile.
       attr_accessor :manifests_path
+
+      # The name of the Configuration module
+      #
+      # Defaults to the basename of the "configuration_file"
+      # e.g. "Foo.ps1" becomes "Foo"
       attr_accessor :configuration_name
+
+      # Set of module paths relative to the Vagrantfile dir.
+      #
+      # These paths are added to the DSC Configuration running
+      # environment to enable local modules to be addressed.
+      #
+      # @return [Array] Set of relative module paths.
       attr_accessor :module_path
-      attr_accessor :options
+
+      # The type of synced folders to use when sharing the data
+      # required for the provisioner to work properly.
+      #
+      # By default this will use the default synced folder type.
+      # For example, you can set this to "nfs" to use NFS synced folders.
       attr_accessor :synced_folder_type
+
+      # Temporary working directory on the guest machine.
       attr_accessor :temp_dir
-      attr_accessor :working_directory
+
+      # Fully qualified path to the configuration file.
+      #
+      # Do not override this.
+      attr_accessor :expanded_configuration_file
 
       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
-
+        @configuration_file     = UNSET_VALUE
+        @manifests_path         = UNSET_VALUE
+        @configuration_name     = UNSET_VALUE
+        @mof_path               = UNSET_VALUE
+        @module_path            = UNSET_VALUE
+        @configuration_params   = {}
+        @synced_folder_type     = UNSET_VALUE
+        @temp_dir               = 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
-
+      # Final step of the Configuration lifecyle prior to
+      # validation.
+      #
+      # Ensures all attributes are set to defaults if not provided.
       def finalize!
         super
 
-        @manifest_file      = "default.ps1" if @manifest_file == UNSET_VALUE
+        # Null checks
+        @configuration_file = "default.ps1" if @configuration_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)
+        @mof_path           = nil if @mof_path == UNSET_VALUE
+        @configuration_name = File.basename(@configuration_file, File.extname(@configuration_file)) if @configuration_name == UNSET_VALUE
+        @manifests_path     = File.dirname(@configuration_file) if @manifests_path == UNSET_VALUE
+
+        # Can't supply them both!
+        if (@configuration_file != nil && @mof_path != nil)
+          raise DSCError, :manifest_and_mof_provided
+        end
 
         # Set a default temp dir that has an increasing counter so
         # that multiple DSC definitions won't overwrite each other
@@ -62,6 +104,9 @@ module VagrantPlugins
 
       # Returns the module paths as an array of paths expanded relative to the
       # root path.
+      #
+      # @param [String|Array] root_path The relative path to expand module paths against.
+      # @return [Array] Set of fully qualified paths to the modules directories.
       def expanded_module_paths(root_path)
         return [] if !module_path
 
@@ -70,13 +115,17 @@ module VagrantPlugins
         paths = module_path
         paths = [paths] if !paths.is_a?(Array)
         paths.map do |path|
-          Pathname.new(path).expand_path(root_path)
+          Pathname.new(path).expand_path(root_path).to_s
         end
       end
 
+      # Validate configuration and return a hash of errors.
       #
-      # Validate configuration
+      # Does not check that DSC itself is properly configured, which is performed
+      # at run-time.
       #
+      # @param [Machine] The current {Machine}
+      # @return [Hash] Any errors or {} if no errors found
       def validate(machine)
         @logger.info("==> Configurin' DSC man!")
         errors = _detected_errors
@@ -85,20 +134,22 @@ module VagrantPlugins
         this_expanded_module_paths = expanded_module_paths(machine.env.root_path)
 
         # Manifest file validation
+        this_expanded_module_paths.each do |path|
+          errors << I18n.t("vagrant_dsc.errors.module_path_missing", path: path) if !Pathname.new(path).expand_path(machine.env.root_path).directory?
+        end
+
+        expanded_path = Pathname.new(manifests_path).
+            expand_path(machine.env.root_path)
+
+        if !expanded_path.directory?
+          errors << I18n.t("vagrant_dsc.errors.manifests_path_missing",
+                           path: expanded_path.to_s)
+        end
 
-        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
+        @expanded_configuration_file = expanded_path.join(File.basename(configuration_file))
+        if !expanded_configuration_file.file? && !expanded_configuration_file.directory?
+          errors << I18n.t("vagrant_dsc.errors.manifest_missing",
+                           manifest: expanded_configuration_file.to_s)
         end
 
         { "dsc provisioner" => errors }

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

@@ -30,3 +30,9 @@ en:
         "Path to DSC Manifest folder does not exist: %{path}"
       manifest_missing: |-
         "Path to DSC Manifest does not exist: %{manifest}"
+      manifest_and_mof_provided: |-
+        "Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two."
+      unsupported_operation: |-
+        "Operation unsupported / not-yet implemented: %{operation}"
+      absolute_module_path: |-
+        "Absolute 'module_path' not allowed. Please provide a path relative to your Vagrantfile."

data/lib/vagrant-dsc/plugin.rb

@@ -5,8 +5,8 @@ module VagrantPlugins
     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.
+        Provides support for provisioning your virtual machines with
+        DSC either using a local `DSC` Configuration or a DSC server.
       DESC
 
       config(:dsc, :provisioner) do

data/lib/vagrant-dsc/provisioner.rb

@@ -3,28 +3,47 @@ require 'erb'
 
 module VagrantPlugins
   module DSC
+    # DSC Errors namespace, including setup of locale-based error messages.
     class DSCError < Vagrant::Errors::VagrantError
       error_namespace("vagrant_dsc.errors")
       I18n.load_path << File.expand_path("locales/en.yml", File.dirname(__FILE__))
     end
-
+    class DSCUnsupportedOperation < DSCError
+      error_key(:unsupported_operation)
+    end    
+
+    # DSC Provisioner Plugin.
+    #
+    # Runs the [Desired State Configuration](http://technet.microsoft.com/en-au/library/dn249912.aspx) system
+    # on a guest Virtual Machine, enabling you to quickly configure & bootstrap a Windows Virtual Machine in a repeatable,
+    # reliable fashion - the Vagrant way.
     class Provisioner < Vagrant.plugin("2", :provisioner)
-      POWERSHELL_VERSION = 5
+      PowerShell_VERSION = 4
+
+      # Default path for storing the transient script runner
+      # This should be removed in cleanup
       DSC_GUEST_RUNNER_PATH = "c:/tmp/vagrant-dsc-runner.ps1"
 
+      # Constructs the Provisioner Plugin.
+      #
+      # @param [Machine] machine The guest machine that is to be provisioned.
+      # @param [Config] config The Configuration object used by the Provisioner.
+      # @returns Provisioner
       def initialize(machine, config)
         super
 
         @logger = Log4r::Logger.new("vagrant::provisioners::dsc")
       end
 
+      # Configures the Provisioner.
+      #
+      # @param [Config] root_config The default configuration from the Vagrant hierarchy.
       def configure(root_config)
-        @logger.info("==> Configuring DSC man!")
+        @logger.info("==> Configuring DSC")
 
         # 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 = []
@@ -38,6 +57,7 @@ module VagrantPlugins
 
         # 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)
@@ -49,6 +69,7 @@ module VagrantPlugins
         end
       end
 
+      # Provision the guest machine with DSC.
       def provision
         @logger.info("==> Provisioning DSC man! #{Vagrant.source_root}")
 
@@ -75,26 +96,35 @@ module VagrantPlugins
 
         verify_dsc
 
-        generate_dsc_runner_script
-
-        run_dsc_apply
+        run_dsc_apply(generate_dsc_runner_script)
+      end
 
+      # Cleanup after a destroy action.
+      #
+      # This is the method called when destroying a machine that allows
+      # for any state related to the machine created by the provisioner
+      # to be cleaned up.
+      def cleanup
+        # Remove temp files? Or is this ONLY called in destroy (in which case those files will go anyway...)
       end
 
+      # Local path (guest path) to the manifests directory.
       def manifests_guest_path
           File.join(config.temp_dir, config.manifests_path)
       end
 
+      # Verify that a current version of WMF/Powershell is enabled on the guest.
       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} ",
+            "(($PSVersionTable | ConvertTo-json | ConvertFrom-Json).PSVersion.Major) -ge #{PowerShell_VERSION}",
             error_class: DSCError,
-            error_key: :dsc_incorrect_powershell_version )
+            error_key: :dsc_incorrect_PowerShell_version )
       end
 
+      # Verify the DSC binary is executable on the guest machine.
       def verify_binary(binary)
         @machine.communicate.sudo(
           "which #{binary}",
@@ -105,25 +135,40 @@ module VagrantPlugins
 
       # Install and Configure DSC where possible.
       #
+      # Operation is current unsupported, but is likely to be enabled
+      # as a flag when the plugin detects an unsupported OS.
       def install_dsc
+        # raise DSCError, I18n.t("vagrant_dsc.errors.manifest_missing", operation: "install_dsc")
+        raise DSCUnsupportedOperation,  :operation => "install_dsc"
+        # Install chocolatey
 
         # Ensure .NET 4.5 installed
 
         # Ensure WMF 4.0 is installed
-
       end
 
-      # Generates a Powershell DSC runner script from an ERB template
+      # Generates a PowerShell DSC runner script from an ERB template
+      #
+      # @return [String] The interpolated PowerShell script.
       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,
+            config: @config,
+            module_paths: @module_paths.map { |k,v| v }.join(";"),
+            mof_path: @config.mof_path,
+            configuration_file: @config.configuration_file,
+            configuration_name: @config.configuration_name,
+            temp_path: @config.temp_dir,
+            parameters: @config.configuration_params.map { |k,v| "#{k}" + (!v.nil? ? " \"#{v}\"": '') }.join(" ")
         })
+      end
+
+      # Writes the PowerShell DSC runner script to a location on the guest.
+      #
+      # @param [String] script The PowerShell DSC runner script.
+      # @return [String] the Path to the uploaded location on the guest machine.
+      def write_dsc_runner_script(script)
         guest_script_path = DSC_GUEST_RUNNER_PATH
         file = Tempfile.new(["vagrant-dsc-runner", "ps1"])
         begin
@@ -138,29 +183,28 @@ module VagrantPlugins
         guest_script_path
       end
 
+      # Runs the DSC Configuration over the guest machine.
+      #
+      # Expects
       def run_dsc_apply
 
+        # Check the DSC_GUEST_RUNNER_PATH exists?
+
         # 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}\""
+        command = ".\\'#{DSC_GUEST_RUNNER_PATH}'"
 
         @machine.ui.info(I18n.t(
           "vagrant_dsc.running_dsc",
-          manifest: config.manifest_file))
+          manifest: config.configuration_file))
 
         opts = {
           elevated: true,
@@ -175,6 +219,8 @@ module VagrantPlugins
         end
       end
 
+      # Verify that the shared folders have been properly configured
+      # on the guest machine.
       def verify_shared_folders(folders)
         folders.each do |folder|
           @logger.info("Checking for shared folder: #{folder}")
@@ -184,9 +230,10 @@ module VagrantPlugins
         end
       end
 
+      # If on using WinRM, we can assume we are on Windows
       def windows?
         @machine.config.vm.communicator == :winrm
       end
     end
   end
-end
+end

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

@@ -1,24 +1,32 @@
 #
-# DSC Runner Script.
-# Bootstraps the DSC environment, configuration and runs the DSC Configuration.
+# DSC Runner.
+#
+# Bootstraps the DSC environment, sets up configuration data
+# 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}"
+# Set the local PowerShell Module environment path
+<% if options[:module_paths]  %>
+echo "Adding to path: <%= options[:module_paths] %>"
+$env:PSModulePath="<%= options[:module_paths] %>;${env:PSModulePath}"
 <% end %>
 
+$script = $(Join-Path "<%= options[:temp_path] %>" "<%= options[:configuration_file] %>")
 echo "PSModulePath Configured: ${env:PSModulePath}"
-echo "Running Configuration file: <%= options[:manifest_file_path] %>"
+echo "Running Configuration file: ${script}"
 
+# Generate the MOF file, only if a MOF path not already provided.
+<% if options[:mof_path] == nil %>
 # Import the Manifest
-. $(Join-Path "<%= options[:temp_path] %>" "<%= options[:manifest_file] %>")
+. $script
 
-# 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] %>
+<%=options[:configuration_name]%> -MachineName "localhost" -OutputPath $StagingPath <%= options[:parameters] %>
+<% else %>
+$StagingPath = "<%= options[:mof_path] %>"
+<% end %>
 
 # Start a DSC Configuration run
 Start-DscConfiguration -Force -Wait -Verbose -Path $StagingPath

data/lib/vagrant-dsc/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module Dsc
-    VERSION = "0.0.1"
+    VERSION = "1.0.0"
   end
 end