kitchen-salt 0.0.24 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85be745fefb172f73d8e9ee2ae396fe3d508396b
-  data.tar.gz: f75956c111096fbe7cc7e724b4712a4dbc9d5fa3
+  metadata.gz: 2508f6579671b6cfbb285f7024faa9c4265645d9
+  data.tar.gz: f506596a5019cea93aaada988025bcc1b691a9d2
 SHA512:
-  metadata.gz: ae57f141df5166427ba4cbade9ffe04b3a5fbb0bf9579d4d1822128a3b55ecca3afc51ffd343b831feb412e1f91ec45339c01041f25fba46c3916f95c1276904
-  data.tar.gz: 8987519c6d89c2010dee394e96df3f1eb6bba1237c3b8044bd527662c24f0d19aadb1f644825275b615cbac7eee58e0deb824d88f81fad8b3fbee21a400fcb5e
+  metadata.gz: 8af0c3817e2fd7e454eb7343dd2b9d013caa7e42a228c53a2fe46231390bb8b1f73b9aa08a59d74ce6e5c565039ae53ec21979c424a8cc99b9b74986cf8fa6ed
+  data.tar.gz: 34f6645a153a85fd2126491768c2402776d4235f31e132b5e7e75de757cd40e63de05119b9d4c2330698732ba4ff199e3bbcc43391d8841f11ef29be2ee4918d

data/lib/kitchen-salt/pillars.rb

@@ -0,0 +1,73 @@
+module Kitchen
+  module Salt
+    module Pillars
+      private
+
+      def prepare_pillars
+        info("Preparing pillars into #{config[:salt_pillar_root]}")
+
+        pillars = config[:pillars]
+        pillars_from_files = config[:'pillars-from-files']
+        debug("Pillars Hash: #{pillars}")
+
+        if pillars.nil? && pillars_from_files.nil?
+          if not config[:local_salt_root].nil?
+            pillars_location = File.join(config[:local_salt_root], 'pillar')
+            sandbox_pillar_path = File.join(sandbox_path, config[:salt_pillar_root])
+            cp_r_with_filter(pillars_location, sandbox_pillar_path, config[:salt_copy_filter])
+            return
+          end
+          return
+        end
+
+        # we get a hash with all the keys converted to symbols, salt doesn't like this
+        # to convert all the keys back to strings again
+        pillars = unsymbolize(pillars)
+        debug("unsymbolized pillars hash: #{pillars}")
+
+        # write out each pillar (we get key/contents pairs)
+        prepare_pillar_files(pillars)
+
+        # copy the pillars from files straight across, as YAML.load/to_yaml and
+        # munge multiline strings
+        unless pillars_from_files.nil?
+          prepare_pillars_from_files(pillars_from_files)
+        end
+      end
+
+      def prepare_pillar_files(pillars)
+        pillars.each do |key, contents|
+          # convert the hash to yaml
+          pillar = contents.to_yaml
+
+          # .to_yaml will produce ! '*' for a key, Salt doesn't like this either
+          pillar.gsub!(/(!\s'\*')/, "'*'")
+
+          # generate the filename
+          sandbox_pillar_path = File.join(sandbox_path, config[:salt_pillar_root], key)
+
+          debug("Rendered pillar yaml for #{key}:\n #{pillar}")
+          write_raw_file(sandbox_pillar_path, pillar)
+        end
+      end
+
+      def copy_pillar(key, srcfile)
+        debug("Copying external pillar: #{key}, #{srcfile}")
+        # generate the filename
+        sandbox_pillar_path = File.join(sandbox_path, config[:salt_pillar_root], key)
+        # create the directory where the pillar file will go
+        FileUtils.mkdir_p(File.dirname(sandbox_pillar_path))
+        # copy the file across
+        FileUtils.copy srcfile, sandbox_pillar_path
+      end
+
+      def prepare_pillars_from_files(pillars)
+        external_pillars = unsymbolize(pillars)
+        debug("external_pillars (unsymbolize): #{external_pillars}")
+        external_pillars.each do |key, srcfile|
+          copy_pillar(key, srcfile)
+        end
+      end
+    end
+  end
+end

data/lib/kitchen-salt/states.rb

@@ -0,0 +1,107 @@
+module Kitchen
+  module Salt
+    module States
+      private
+
+      def prepare_state_top
+        info('Preparing state_top')
+
+        sandbox_state_top_path = File.join(sandbox_path, config[:salt_state_top])
+
+        if config[:state_top_from_file] == false
+          # use the top.sls embedded in .kitchen.yml
+
+          # we get a hash with all the keys converted to symbols, salt doesn't like this
+          # to convert all the keys back to strings again
+          state_top_content = unsymbolize(config[:state_top]).to_yaml
+          # .to_yaml will produce ! '*' for a key, Salt doesn't like this either
+          state_top_content.gsub!(/(!\s'\*')/, "'*'")
+        else
+          # load a top.sls from disk
+          if config[:local_salt_root].nil?
+            top_file = 'top.sls'
+          else
+            top_file = File.join(config[:local_salt_root], 'salt/top.sls')
+          end
+          state_top_content = File.read(top_file)
+        end
+
+        write_raw_file(sandbox_state_top_path, state_top_content)
+      end
+
+      def prepare_states
+        if config[:state_collection] || config[:is_file_root] || !config[:local_salt_root].nil?
+          prepare_state_collection
+        else
+          prepare_formula config[:kitchen_root], config[:formula]
+          prepare_vendor_states
+        end
+
+      end
+
+      def prepare_vendor_states
+        vendor_path = config[:vendor_path]
+
+        unless vendor_path.nil?
+          if Pathname.new(vendor_path).exist?
+            Dir[File.join(vendor_path, '*')].each do |d|
+              prepare_formula vendor_path, File.basename(d)
+            end
+          else
+            # :vendor_path was set, but not valid
+            raise UserError, "kitchen-salt: Invalid vendor_path set: #{vendor_path}"
+          end
+        end
+      end
+
+      def prepare_formula_dir(path, subdir)
+        src = File.join(path, subdir)
+
+        if File.directory?(src)
+          debug("prepare_formula_dir: #{src} exists, copying..")
+          subdir_path = File.join(sandbox_path, config[:salt_file_root], subdir)
+          FileUtils.mkdir_p(subdir_path)
+          cp_r_with_filter(src, subdir_path, config[:salt_copy_filter])
+        else
+          debug("prepare_formula_dir: #{src} doesn't exist, skipping.")
+        end
+      end
+
+      def prepare_formula(path, formula)
+        info("Preparing formula: #{formula} from #{path}")
+        debug("Using config #{config}")
+
+        formula_dir = File.join(sandbox_path, config[:salt_file_root], formula)
+        FileUtils.mkdir_p(formula_dir)
+        cp_r_with_filter(File.join(path, formula), formula_dir, config[:salt_copy_filter])
+
+        # copy across the _modules etc directories for python implementation
+        %w(_modules _states _grains _renderers _returners).each do |extrapath|
+          prepare_formula_dir(path, extrapath)
+        end
+      end
+
+      def prepare_state_collection
+        info('Preparing state collection')
+        collection_name = config[:collection_name]
+        formula = config[:formula]
+
+        if collection_name.nil? && formula.nil?
+          info('neither collection_name or formula have been set, assuming this is a pre-built collection')
+          collection_name = ''
+        elsif collection_name.nil?
+          collection_name = formula
+        end
+
+        if config[:local_salt_root].nil?
+          states_location = config[:kitchen_root]
+        else
+          states_location = File.join(config[:local_salt_root], 'salt')
+        end
+        collection_dir = File.join(sandbox_path, config[:salt_file_root], collection_name)
+        FileUtils.mkdir_p(collection_dir)
+        cp_r_with_filter(states_location, collection_dir, config[:salt_copy_filter])
+      end
+    end
+  end
+end

data/lib/kitchen-salt/util.rb

@@ -0,0 +1,69 @@
+require 'find'
+
+module Kitchen
+  module Salt
+    module Util
+      private
+
+      def unsymbolize(obj)
+        if obj.is_a? Hash
+          obj.each_with_object({}) do |(k, v), a|
+            a[k.to_s] = unsymbolize(v)
+            a
+          end
+        elsif obj.is_a? Array
+          obj.each_with_object([]) do |e, a|
+            a << unsymbolize(e)
+            a
+          end
+        else
+          obj
+        end
+      end
+
+      def cp_r_with_filter(source_paths, target_path, filter = [])
+        debug("cp_r_with_filter:source_paths = #{source_paths}")
+        debug("cp_r_with_filter:target_path = #{target_path}")
+        debug("cp_r_with_filter:filter = #{filter}")
+
+        Array(source_paths).each do |source_path|
+          _cp_r_with_filter(source_path, target_path, filter)
+        end
+      end
+
+      def _cp_r_with_filter(source_path, target_path, filter = [])
+        Find.find(source_path) do |source|
+          target = source.sub(/^#{source_path}/, target_path)
+          debug("cp_r_with_filter:source = #{source}")
+          debug("cp_r_with_filter:target = #{target}")
+          filtered = filter.include?(File.basename(source))
+          if File.directory? source
+            if filtered
+              debug("Found #{source} in #{filter}, pruning it from the Find")
+              Find.prune
+            end
+            FileUtils.mkdir_p target unless File.exist? target
+
+            FileUtils.cp_r "#{source}/.", target if File.symlink? source
+          elsif filtered
+            debug("Found #{source} in #{filter}, not copying file")
+          else
+            FileUtils.copy source, target
+          end
+        end
+      end
+
+      def write_raw_file(name, contents)
+        FileUtils.mkdir_p(File.dirname(name))
+        File.open(name, 'wb') do |file|
+          file.write(contents)
+        end
+      end
+
+      def write_hash_file(name, contents)
+        raw_contents = unsymbolize(contents).to_yaml
+        write_raw_file(name, raw_contents)
+      end
+    end
+  end
+end

data/lib/kitchen-salt/version.rb

@@ -1,5 +1,5 @@
 module Kitchen
   module Salt
-    VERSION = "0.0.24"
+    VERSION = '0.0.25'.freeze
   end
 end

data/lib/kitchen/provisioner/dependencies.erb

@@ -0,0 +1,99 @@
+<%=
+
+def install_dependencies
+  script = ''
+
+  script += <<-INSTALL
+    test ! -e "$(dirname $0)/formula-fetch.sh" || . "$(dirname $0)/formula-fetch.sh"
+    test ! -e "$(dirname $0)/repository-setup.sh" || . "$(dirname $0)/repository-setup.sh"
+
+    export SALT_ROOT="#{config[:root_path]}/#{config[:salt_file_root]}";
+    mkdir -p "${SALT_ROOT}";
+  INSTALL
+
+
+  # setup apt
+  config[:vendor_repo].select{|x| x[:type]=='apt'}.each do |repo|
+    id  =repo[:url].gsub(/[htp:\/.]/,'')
+    arch=repo[:arch] || '[arch=amd64]'
+    rurl=repo[:url]
+    comp=repo[:components] || 'main'
+    dist=repo[:distribution] || '$DISTRIB_CODENAME'
+    rkey=repo[:key_url]
+    script += <<-INSTALL
+      apt_repo_add "#{id}" "#{arch}" "#{rurl}" "#{comp}" "#{dist}" "#{rkey}";
+    INSTALL
+  end
+
+  # setup ppa
+  config[:vendor_repo].select{|x| x[:type]=='ppa'}.each do |repo|
+    script += <<-INSTALL
+        #{sudo('add-apt-repository')} "ppa:#{repo[:name]}" -y;
+    INSTALL
+  end
+
+  # TODO, setup yum repo
+
+  # update resources
+  config[:vendor_repo].map{|x| x[:type]}.uniq.each do |type|
+    case type
+    when 'apt'
+      script += <<-INSTALL
+        #{sudo('apt-get')} update -q;
+        sleep 10;
+      INSTALL
+    when 'yum'
+      script += <<-INSTALL
+        #{sudo('yum')} update;
+        sleep 10;
+      INSTALL
+    when 'spm'
+      script += <<-INSTALL
+        #{sudo('spm')} update_repo;
+      INSTALL
+    end
+  end
+
+  # install formulas
+  config[:dependencies].select{|dependency| dependency.has_key?(:repo)}.each do |formula|
+    #unless config[:vendor_repo].has_key?(formula[:repo])
+    #  raise UserError, "kitchen-salt: Invalid dependency formula :repo, no such vendor_repo '#{formula[:repo]}' specified."
+    #end
+    case formula[:repo]
+    when 'git'
+      script += <<-INSTALL
+        fetchGitFormula #{formula[:source]} "#{formula[:name]}" "#{formula[:branch] || 'master'}"
+      INSTALL
+    when 'spm'
+      # TODO: SPM should know the sandbox_path is /tmp/kitchen/etc
+      script += <<-INSTALL
+        #{sudo('spm')} install #{formula[:package]||formula[:name]};
+      INSTALL
+    when 'yum'
+      script += <<-INSTALL
+        #{sudo('yum')} install -y #{formula[:package]||formula[:name]};
+      INSTALL
+    when 'apt'
+      script += <<-INSTALL
+        #{sudo('apt-get')} install -y #{formula[:package]||formula[:name]};
+      INSTALL
+    end
+  end
+  script += <<-INSTALL
+    linkFormulas "$SALT_ROOT"
+    #{sudo('chown')} kitchen.kitchen -R /usr/share/salt-formulas;
+    #{sudo('chown')} kitchen.kitchen -R "$SALT_ROOT";
+    ls -la "$SALT_ROOT";
+  INSTALL
+  return script
+end
+
+
+<<-INSTALL
+#!/bin/bash
+
+echo "Install External Dependencies";
+#{install_dependencies}
+
+INSTALL
+%>

data/lib/kitchen/provisioner/formula-fetch.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+# Usage:
+#    ./formula-fetch.sh <Formula URL> <Name> <Branch>
+#
+# Example:
+#    GIT_FORMULAS_PATH=.vendor/formulas ./formula-fetch.sh https://github.com/salt-formulas/salt-formula-salt
+#    --
+#    GIT_FORMULAS_PATH=/usr/share/salt-formulas/env/_formulas
+#    xargs -n1 ./formula-fetch.sh < dependencies.txt
+
+
+# Parse git dependencies from metadata.yml
+# $1 - path to <formula>/metadata.yml
+# sample to output:
+#    https://github.com/salt-formulas/salt-formula-git git
+#    https://github.com/salt-formulas/salt-formula-salt salt
+function fetchDependencies() {
+    METADATA="$1";
+    grep -E "^dependencies:" "$METADATA" >/dev/null || return 0
+    # shellcheck disable=SC2086
+    (python - "$METADATA" | while read -r dep; do fetchGitFormula $dep; done) <<-DEPS 
+		import sys,yaml
+		for dep in yaml.load(open(sys.argv[1], "ro"))["dependencies"]:
+		  print("{source} {name}").format(**dep)
+		DEPS
+}
+
+# Fetch formula from git repo
+# $1 - formula git repo url
+# $2 - formula name (optional)
+# $3 - branch (optional)
+function fetchGitFormula() {
+    test -n "${FETCHED}" || declare -a FETCHED=()
+    export GIT_FORMULAS_PATH=${GIT_FORMULAS_PATH:-/usr/share/salt-formulas/env/_formulas}
+    mkdir -p "$GIT_FORMULAS_PATH"
+    if [ -n "$1" ]; then
+        source="$1"
+        name="$2"
+        test -n "$name" || name="${source//*salt-formula-}"
+        test -z "$3" && branch=master || branch=$3
+        if ! [[ "${FETCHED[*]}" =~ $name ]]; then # dependency not yet fetched
+          echo "Fetching: $name"
+          if test -e "$GIT_FORMULAS_PATH/$name"; then
+              pushd "$GIT_FORMULAS_PATH/$name" &>/dev/null
+              test ! -e .git || git pull -r
+              popd &>/dev/null
+          else
+              echo "git clone $source $GIT_FORMULAS_PATH/$name -b $branch"
+              git clone "$source" "$GIT_FORMULAS_PATH/$name" -b "$branch"
+          fi
+          # install dependencies
+          FETCHED+=($name)
+          fetchDependencies "$GIT_FORMULAS_PATH/$name/metadata.yml"
+        fi
+    else
+        echo Usage: fetchGitFormula "<git repo>" "[local formula directory name]" "[branch]"
+    fi
+}
+
+function linkFormulas() {
+  # OPTIONAL: Link formulas from git/pkg
+
+  SALT_ROOT=$1
+  SALT_ENV=${2:-/usr/share/salt-formulas/env}
+
+  # form git, development versions
+  find "$SALT_ENV"/_formulas -maxdepth 1 -mindepth 1 -type d -print0| xargs -0 -n1 basename | xargs -I{} \
+    ln -fs "$SALT_ENV"/_formulas/{}/{} "$SALT_ROOT"/{};
+
+  # form pkgs
+  find "$SALT_ENV" -path "*_formulas*" -prune -o -name "*" -maxdepth 1 -mindepth 1 -type d -print0| xargs -0 -n1 basename | xargs -I{} \
+    ln -fs "$SALT_ENV"/{} "$SALT_ROOT"/{};
+
+}
+
+# detect if file is being sourced
+[[ "$0" != "${BASH_SOURCE[@]}" ]] || {
+    # if executed, run implicit function
+    fetchGitFormula "${@}"
+}
+

data/lib/kitchen/provisioner/install.erb

@@ -0,0 +1,82 @@
+
+<%=
+salt_install = config[:salt_install]
+salt_url = config[:salt_bootstrap_url]
+bootstrap_options = config[:salt_bootstrap_options]
+salt_version = config[:salt_version]
+salt_apt_repo = config[:salt_apt_repo]
+salt_apt_repo_key = config[:salt_apt_repo_key]
+salt_ppa = config[:salt_ppa]
+
+<<-INSTALL
+sh -c '
+#{Util.shell_helpers}
+
+# what version of salt is installed?
+SALT_VERSION=`salt-call --version | cut -d " " -f 2`
+set +x
+
+
+if [ -z "${SALT_VERSION}" -a "#{salt_install}" = "bootstrap" ]
+then
+  do_download #{salt_url} /tmp/bootstrap-salt.sh
+  #{sudo('sh')} /tmp/bootstrap-salt.sh #{bootstrap_options}
+elif [ -z "${SALT_VERSION}" -a "#{salt_install}" = "apt" ]
+then
+  if [ ! $(command -v lsb_release &>/dev/null) ]; then
+    . /etc/lsb-release
+  else
+    DISTRIB_CODENAME=$(lsb_release -s -c)
+  fi
+
+  echo "-----> Configuring apt repo for salt #{salt_version}"
+  echo "deb #{salt_apt_repo}/#{salt_version} ${DISTRIB_CODENAME} main" | #{sudo('tee')} /etc/apt/sources.list.d/salt-#{salt_version}.list
+
+  do_download #{salt_apt_repo_key} /tmp/repo.key
+  #{sudo('apt-key')} add /tmp/repo.key
+
+  #{sudo('apt-get')} update
+  sleep 10
+  echo "-----> Installing salt-minion (#{salt_version})"
+  #{sudo('apt-get')} install -y python-support
+  #{sudo('apt-get')} install -y salt-minion salt-common
+elif [ -z "${SALT_VERSION}" -a "#{salt_install}" = "distrib" ]
+then
+  #{sudo('apt-get')} update
+  #{sudo('apt-get')} install -y salt-minion
+elif [ -z "${SALT_VERSION}" -a "#{salt_install}" = "ppa" ]
+then
+  #{sudo('apt-add-repository')} -y #{salt_ppa}
+  #{sudo('apt-get')} update
+  #{sudo('apt-get')} install -y salt-minion salt-common
+fi
+
+# check again, now that an install of some form should have happened
+SALT_VERSION=`salt-call --version | cut -d " " -f 2`
+
+if [ -z "${SALT_VERSION}" ]
+then
+  echo "No salt-minion installed, install must have failed!!"
+  echo "salt_install = #{salt_install}"
+  echo "salt_url = #{salt_url}"
+  echo "bootstrap_options = #{bootstrap_options}"
+  echo "salt_version = #{salt_version}"
+  echo "salt_apt_repo = #{salt_apt_repo}"
+  echo "salt_apt_repo_key = #{salt_apt_repo_key}"
+  echo "salt_ppa = #{salt_ppa}"
+  exit 2
+elif [ "${SALT_VERSION}" = "#{salt_version}" -o "#{salt_version}" = "latest" ]
+then
+  echo "You asked for #{salt_version} and you have ${SALT_VERSION} installed, sweet!"
+elif [ ! -z "${SALT_VERSION}" -a "#{salt_install}" = "bootstrap" ]
+then
+  echo "You asked for bootstrap install and you have got ${SALT_VERSION}, hope thats ok!"
+else
+  echo "You asked for #{salt_version} and you have got ${SALT_VERSION} installed, dunno how to fix that, sorry!"
+  exit 2
+fi
+
+#{install_chef}
+'
+INSTALL
+%>

data/lib/kitchen/provisioner/install_win.erb

@@ -0,0 +1,32 @@
+<%=
+salt_install = config[:salt_install]
+salt_url = config[:salt_bootstrap_url]
+bootstrap_options = config[:salt_bootstrap_options]
+salt_version = config[:salt_version]
+
+<<-POWERSHELL
+if (Test-Path c:\\salt\\salt-call.bat) {
+  $installed_version = $(c:\\salt\\salt-call.bat --version).split(' ')[1] 
+}
+if (-Not $(Test-Path c:\\temp)) {
+  New-Item -Path c:\\temp -itemtype directory
+}
+if (-Not $installed_version -And "#{salt_install}" -eq "bootstrap") {
+  (New-Object net.webclient).DownloadFile("#{salt_url}", "c:\\temp\\salt_bootstrap.ps1")
+  #{sudo('powershell')} c:\\temp\\salt_bootstrap.ps1 #{bootstrap_options}
+}
+$installed_version = $(c:\\salt\\salt-call.bat --version).split(' ')[1] 
+if (-Not $installed_version) {
+  write-host "No salt-minion installed, install must have failed!!"
+  write-host "salt_install = #{salt_install}"
+  write-host "salt_url = #{salt_url}"
+  write-host "bootstrap_options = #{bootstrap_options}"
+} elseif ($installed_version -And "#{salt_install}" -eq "bootstrap") {
+  write-host "You asked for bootstrap install and you have got $installed_version, hope that's ok!"
+} else {
+  write-host "You asked for #{salt_version} and you have got $installed_version installed, dunno ho to fix that, sorry!"
+  exit 2
+}
+#{install_chef}
+POWERSHELL
+%>

data/lib/kitchen/provisioner/minion.erb

@@ -0,0 +1,13 @@
+state_top: top.sls
+
+file_client: local
+
+file_roots:
+ <%= config[:salt_env] %>:
+
+   - <%= File.join(config[:root_path], (windows_os? ? config[:salt_file_root].gsub('/', '\\') : config[:salt_file_root])) %>
+   - <%= File.join(config[:root_path], (windows_os? ? config[:salt_file_root].gsub('/', '\\') : config[:salt_file_root]), 'spm') %>
+
+pillar_roots:
+ <%= config[:salt_env] %>:
+   - <%= File.join(config[:root_path], (windows_os? ? config[:salt_pillar_root].gsub('/', '\\') : config[:salt_pillar_root])) %>

data/lib/kitchen/provisioner/repository-setup.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+function apt_repo_add {
+  id="$1"
+  arch="$2"
+  rurl="$3"
+  comp="$4"
+  dist="$5"
+  rkey="$6"
+  test -e /tmp/apt_repo_vendor_"${id}".key || {
+    echo "-----> Configuring formula apt vendor_repo ${rurl}"
+    eval "$(cat /etc/lsb-release)"
+    if curl -k "${rkey}" -o /tmp/apt_repo_vendor_"${id}".key; then
+      echo "deb ${arch} ${rurl} ${dist} ${comp}" | tee /etc/apt/sources.list.d/vendor-repo.list
+      apt-key add /tmp/apt_repo_vendor_"${id}".key
+    fi
+  };
+}
+
+# detect if file is being sourced
+[[ "$0" != "${BASH_SOURCE[@]}" ]] || {
+    # if executed, run implicit function
+    #apt_repo_add "${@}"
+    echo 'Usage: apt_repo_add "custom id" "arch" "repo url" "components" "distribution" "repo gpg key"';
+}
+

data/lib/kitchen/provisioner/salt_solo.rb

@@ -17,163 +17,122 @@
 # limitations under the License.
 
 require 'kitchen/provisioner/base'
-require 'find'
+require 'kitchen-salt/util'
+require 'kitchen-salt/pillars'
+require 'kitchen-salt/states'
 require 'fileutils'
 require 'yaml'
 
 module Kitchen
-
   module Provisioner
-
     # Basic Salt Masterless Provisioner, based on work by
     #
     # @author Chris Lundquist (<chris.ludnquist@github.com>)
-    class SaltSolo < Base
-
-      default_config :salt_version, "latest"
-
-      # supported install methods: bootstrap|apt
-      default_config :salt_install, "bootstrap"
-
-      default_config :salt_bootstrap_url, "http://bootstrap.saltstack.org"
-      default_config :salt_bootstrap_options, ""
 
-      # alternative method of installing salt
-      default_config :salt_apt_repo, "http://apt.mccartney.ie"
-      default_config :salt_apt_repo_key, "http://apt.mccartney.ie/KEY"
-      default_config :salt_ppa, "ppa:saltstack/salt"
-
-      default_config :chef_bootstrap_url, "https://www.getchef.com/chef/install.sh"
-
-      default_config :salt_config, "/etc/salt"
-      default_config :salt_minion_config, "/etc/salt/minion"
-      default_config :salt_env, "base"
-      default_config :salt_file_root, "/srv/salt"
-      default_config :salt_pillar_root, "/srv/pillar"
-      default_config :salt_state_top, "/srv/salt/top.sls"
-      default_config :state_collection, false
-      default_config :state_top, {}
-      default_config :state_top_from_file, false
-      default_config :salt_run_highstate, true
-      default_config :salt_copy_filter, []
-      default_config :is_file_root, false
-      default_config :require_chef, true
-
-      default_config :dependencies, []
-      default_config :vendor_path, nil
-      default_config :omnibus_cachier, false
+    class SaltSolo < Base
+      include Kitchen::Salt::Util
+      include Kitchen::Salt::Pillars
+      include Kitchen::Salt::States
+
+      DEFAULT_CONFIG = {
+        dry_run: false,
+        salt_version: 'latest',
+        salt_install: 'bootstrap',
+        salt_bootstrap_url: 'https://bootstrap.saltstack.org',
+        salt_bootstrap_options: '',
+        salt_apt_repo: 'https://repo.saltstack.com/apt/ubuntu/16.04/amd64/latest',
+        salt_apt_repo_key: 'https://repo.saltstack.com/apt/ubuntu/16.04/amd64/latest/SALTSTACK-GPG-KEY.pub',
+        salt_ppa: 'ppa:saltstack/salt',
+        bootstrap_url: 'https://raw.githubusercontent.com/saltstack/kitchen-salt/master/assets/install.sh',
+        chef_bootstrap_url: 'https://www.getchef.com/chef/install.sh',
+        salt_config: '/etc/salt',
+        salt_minion_config: '/etc/salt/minion',
+        salt_minion_config_template: nil,
+        salt_minion_id: nil,
+        salt_env: 'base',
+        salt_file_root: '/srv/salt',
+        salt_pillar_root: '/srv/pillar',
+        salt_spm_root: '/srv/spm',
+        salt_state_top: '/srv/salt/top.sls',
+        state_collection: false,
+        state_top: {},
+        state_top_from_file: false,
+        salt_run_highstate: true,
+        salt_copy_filter: [],
+        is_file_root: false,
+        require_chef: true,
+        dependencies: [],
+        vendor_path: nil,
+        vendor_repo: {},
+        omnibus_cachier: false,
+        local_salt_root: nil
+      }
 
       # salt-call version that supports the undocumented --retcode-passthrough command
-      RETCODE_VERSION = '0.17.5'
+      RETCODE_VERSION = '0.17.5'.freeze
+
+      DEFAULT_CONFIG.each do |k, v|
+        default_config k, v
+      end
 
       def install_command
-        debug(diagnose())
+        debug(diagnose)
+        salt_version = config[:salt_version]
 
         # if salt_verison is set, bootstrap is being used & bootstrap_options is empty,
         # set the bootstrap_options string to git install the requested version
-        if ((config[:salt_version] != 'latest') && (config[:salt_install] == 'bootstrap') && config[:salt_bootstrap_options].empty?)
-          debug("Using bootstrap git to install #{config[:salt_version]}")
-          config[:salt_bootstrap_options] = "-P git v#{config[:salt_version]}"
+        if (salt_version != 'latest') && (config[:salt_install] == 'bootstrap') && config[:salt_bootstrap_options].empty?
+          debug("Using bootstrap git to install #{salt_version}")
+          config[:salt_bootstrap_options] = "-P git v#{salt_version}"
         end
 
-        salt_install = config[:salt_install]
-
-        salt_url = config[:salt_bootstrap_url]
-        bootstrap_options = config[:salt_bootstrap_options]
-
-        salt_version = config[:salt_version]
-        salt_apt_repo = config[:salt_apt_repo]
-        salt_apt_repo_key = config[:salt_apt_repo_key]
-        salt_ppa = config[:salt_ppa]
-
-
-        <<-INSTALL
-          sh -c '
-          #{Util.shell_helpers}
-
-          # what version of salt is installed?
-          SALT_VERSION=`salt-call --version | cut -d " " -f 2`
-
-
-          if [ -z "${SALT_VERSION}" -a "#{salt_install}" = "bootstrap" ]
-          then
-            do_download #{salt_url} /tmp/bootstrap-salt.sh
-            #{sudo('sh')} /tmp/bootstrap-salt.sh #{bootstrap_options}
-          elif [ -z "${SALT_VERSION}" -a "#{salt_install}" = "apt" ]
-          then
-            if [ -z "`which lsb_release`" ]; then
-              . /etc/lsb-release
-            else
-              DISTRIB_CODENAME=`lsb_release -s -c`
-            fi
-
-            echo "-----> Configuring apt repo for salt #{salt_version}"
-            echo "deb #{salt_apt_repo}/salt-#{salt_version} ${DISTRIB_CODENAME} main" | #{sudo('tee')} /etc/apt/sources.list.d/salt-#{salt_version}.list
-
-            do_download #{salt_apt_repo_key} /tmp/repo.key
-            #{sudo('apt-key')} add /tmp/repo.key
-
-            #{sudo('apt-get')} update
-            sleep 10
-            echo "-----> Installing salt-minion (#{salt_version})"
-            #{sudo('apt-get')} install -y python-support
-            #{sudo('apt-get')} install -y salt-minion
-            #{sudo('apt-get')} install -y salt-common
-            #{sudo('apt-get')} install -y salt-minion
-          elif [ -z "${SALT_VERSION}" -a "#{salt_install}" = "ppa" ]
-          then
-            #{sudo('apt-add-repository')} -y #{salt_ppa}
-            #{sudo('apt-get')} update
-            #{sudo('apt-get')} install -y salt-minion
-          fi
-
-          # check again, now that an install of some form should have happened
-          SALT_VERSION=`salt-call --version | cut -d " " -f 2`
-
-          if [ -z "${SALT_VERSION}" ]
-          then
-            echo "No salt-minion installed, install must have failed!!"
-            echo "salt_install = #{salt_install}"
-            echo "salt_url = #{salt_url}"
-            echo "bootstrap_options = #{bootstrap_options}"
-            echo "salt_version = #{salt_version}"
-            echo "salt_apt_repo = #{salt_apt_repo}"
-            echo "salt_apt_repo_key = #{salt_apt_repo_key}"
-            echo "salt_ppa = #{salt_ppa}"
-            exit 2
-          elif [ "${SALT_VERSION}" = "#{salt_version}" -o "#{salt_version}" = "latest" ]
-          then
-            echo "You asked for #{salt_version} and you have ${SALT_VERSION} installed, sweet!"
-          elif [ ! -z "${SALT_VERSION}" -a "#{salt_install}" = "bootstrap" ]
-          then
-            echo "You asked for bootstrap install and you have got ${SALT_VERSION}, hope thats ok!"
-          else
-            echo "You asked for #{salt_version} and you have got ${SALT_VERSION} installed, dunno how to fix that, sorry!"
-            exit 2
-          fi
-
-          #{install_chef}
+        if windows_os?
+          install_template = File.expand_path("./../install_win.erb", __FILE__)
+        else
+          install_template = File.expand_path("./../install.erb", __FILE__)
+        end
 
-          '
-        INSTALL
+        erb = ERB.new(File.read(install_template)).result(binding)
+        debug("Install Command:" + erb.to_s)
+        erb
       end
 
       def install_chef
         return unless config[:require_chef]
         chef_url = config[:chef_bootstrap_url]
-        omnibus_download_dir = config[:omnibus_cachier] ? "/tmp/vagrant-cache/omnibus_chef" : "/tmp"
-        <<-INSTALL
-          if [ ! -d "/opt/chef" ]
-          then
-            echo "-----> Installing Chef Omnibus (for busser/serverspec ruby support)"
-            mkdir -p #{omnibus_download_dir}
-            if [ ! -x #{omnibus_download_dir}/install.sh ]
-            then
-              do_download #{chef_url} #{omnibus_download_dir}/install.sh
-            fi
-            #{sudo('sh')} #{omnibus_download_dir}/install.sh -d #{omnibus_download_dir}
-          fi
-        INSTALL
+        if windows_os?
+          <<-POWERSHELL
+            if (-Not $(test-path c:\\opscode\\chef) { 
+              if (-Not $(Test-Path c:\\temp)) {
+                New-Item -Path c:\\temp -itemtype directory
+              }
+              (New-Object net.webclient).DownloadFile("#{chef_url}", "c:\\temp\\chef_bootstrap.ps1")
+              write-host "-----> Installing Chef Omnibus (for busser/serverspec ruby support)" 
+              #{sudo('powershell')} c:\\temp\\chef_bootstrap.ps1
+            }
+          POWERSHELL
+        else
+            omnibus_download_dir = config[:omnibus_cachier] ? '/tmp/vagrant-cache/omnibus_chef' : '/tmp'
+            bootstrap_url = config[:bootstrap_url]
+            bootstrap_download_dir = '/tmp'
+            <<-INSTALL
+              echo "-----> Trying to install ruby(-dev) using assets.sh from kitchen-salt"
+                mkdir -p #{bootstrap_download_dir}
+                if [ ! -x #{bootstrap_download_dir}/install.sh ]
+                then
+                  do_download #{bootstrap_url} #{bootstrap_download_dir}/install.sh
+                fi
+                #{sudo('sh')} #{bootstrap_download_dir}/install.sh -d #{bootstrap_download_dir}
+              if [ $? -ne 0 ] || [ ! -d "/opt/chef" ]
+              then
+                echo "Failed install ruby(-dev) using assets.sh from kitchen-salt"
+                echo "-----> Fallback to Chef Bootstrap script (for busser/serverspec ruby support)"
+                mkdir -p "#{omnibus_download_dir}"
+                if [ ! -x #{omnibus_download_dir}/install.sh ]
+                    #{sudo('sh')} #{omnibus_download_dir}/install.sh -d #{omnibus_download_dir}
+                fi;
+          INSTALL
+        end
       end
 
       def create_sandbox
@@ -182,75 +141,78 @@ module Kitchen
         prepare_minion
         prepare_pillars
         prepare_grains
-
-        if config[:state_collection] || config[:is_file_root]
-          prepare_state_collection
-        else
-          prepare_formula config[:kitchen_root], config[:formula]
-
-          unless config[:vendor_path].nil?
-            if Pathname.new(config[:vendor_path]).exist?
-              deps = if Pathname.new(config[:vendor_path]).absolute?
-                Dir["#{config[:vendor_path]}/*"]
-              else
-                Dir["#{config[:kitchen_root]}/#{config[:vendor_path]}/*"]
-              end
-
-              deps.each do |d|
-                prepare_formula "#{config[:kitchen_root]}/#{config[:vendor_path]}", File.basename(d)
-              end
-            else
-              # :vendor_path was set, but not valid
-              raise UserError, "kitchen-salt: Invalid vendor_path set: #{config[:vendor_path]}"
-            end
-          end
-        end
-
-        config[:dependencies].each do |formula|
-          prepare_formula formula[:path], formula[:name]
-        end
+        prepare_states
         prepare_state_top
+        # upload scripts, cached formulas, and setup system repositories
+        prepare_dependencies
       end
 
       def init_command
-        debug("Initialising Driver #{self.name} by cleaning #{config[:root_path]}")
-        "#{sudo('rm')} -rf #{config[:root_path]} ; mkdir -p #{config[:root_path]}"
+        debug("Initialising Driver #{name}")
+        if windows_os?
+          cmd = "mkdir -Force -Path ""#{config[:root_path]}"""
+        else
+          cmd = "mkdir -p '#{config[:root_path]}';"
+        end
+        cmd += <<-INSTALL
+          #{config[:init_environment]}
+        INSTALL
+        cmd
       end
 
-      def run_command
-        debug("running driver #{self.name}")
-        # sudo(File.join(config[:root_path], File.basename(config[:script])))
-        debug(diagnose())
-        if config[:salt_run_highstate]
-          cmd = sudo("salt-call --config-dir=#{File.join(config[:root_path], config[:salt_config])} --local state.highstate")
-        end
+      def salt_command
+        salt_version = config[:salt_version]
 
-        if config[:log_level]
-          cmd << " --log-level=#{config[:log_level]}"
+        cmd = ""
+        if windows_os?
+          salt_call = "c:\\salt\\salt-call.bat"
+          salt_config_path = config[:salt_config].gsub('/', '\\')
+          cmd << "(get-content #{File.join(config[:root_path], salt_config_path, 'minion').gsub('/', '\\')}).replace(\"`$env`:TEMP\", $env:TEMP) | set-content #{File.join(config[:root_path], salt_config_path, 'minion').gsub('/', '\\')} ;"
+        else
+          # install/update dependencies
+          cmd << sudo("chmod +x #{config[:root_path]}/*.sh;")
+          cmd << sudo("#{config[:root_path]}/dependencies.sh;")
+          salt_config_path = config[:salt_config]
+          salt_call = "salt-call"
+        end
+        cmd << sudo("#{salt_call} --state-output=changes --config-dir=#{File.join(config[:root_path], salt_config_path)} --local state.highstate")
+        cmd << " --log-level=#{config[:log_level]}" if config[:log_level]
+        cmd << " --id=#{config[:salt_minion_id]}" if config[:salt_minion_id]
+        cmd << " test=#{config[:dry_run]}" if config[:dry_run]
+        if salt_version > RETCODE_VERSION || salt_version == 'latest'
+          # hope for the best and hope it works eventually
+          cmd << ' --retcode-passthrough'
         end
+        if windows_os?
+          cmd << ' ; exit $LASTEXITCODE'
+        end
+        cmd
+      end
+
+      def run_command
+        debug("running driver #{name}")
+        debug(diagnose)
 
         # config[:salt_version] can be 'latest' or 'x.y.z', 'YYYY.M.x' etc
         # error return codes are a mess in salt:
         #  https://github.com/saltstack/salt/pull/11337
         # Unless we know we have a version that supports --retcode-passthrough
         # attempt to scan the output for signs of failure
-        if config[:salt_version] > RETCODE_VERSION || config[:salt_version] == 'latest'
-          # hope for the best and hope it works eventually
-          cmd = cmd + " --retcode-passthrough"
-        else
+        if config[:salt_version] <= RETCODE_VERSION
           # scan the output for signs of failure, there is a risk of false negatives
           fail_grep = 'grep -e Result.*False -e Data.failed.to.compile -e No.matching.sls.found.for'
           # capture any non-zero exit codes from the salt-call | tee pipe
-          cmd = 'set -o pipefail ; ' << cmd
+          cmd = 'set -o pipefail ; ' << salt_command
           # Capture the salt-call output & exit code
-          cmd << " 2>&1 | tee /tmp/salt-call-output ; SC=$? ; echo salt-call exit code: $SC ;"
+          cmd << ' 2>&1 | tee /tmp/salt-call-output ; SC=$? ; echo salt-call exit code: $SC ;'
           # check the salt-call output for fail messages
           cmd << " (sed '/#{fail_grep}/d' /tmp/salt-call-output | #{fail_grep} ; EC=$? ; echo salt-call output grep exit code ${EC} ;"
           # use the non-zer exit code from salt-call, then invert the results of the grep for failures
-          cmd << " [ ${SC} -ne 0 ] && exit ${SC} ; [ ${EC} -eq 0 ] && exit 1 ; [ ${EC} -eq 1 ] && exit 0)"
+          cmd << ' [ ${SC} -ne 0 ] && exit ${SC} ; [ ${EC} -eq 0 ] && exit 1 ; [ ${EC} -eq 1 ] && exit 0)'
+          cmd
+        else
+          salt_command
         end
-
-        cmd
       end
 
       protected
@@ -258,123 +220,34 @@ module Kitchen
       def prepare_data
         return unless config[:data_path]
 
-        info("Preparing data")
+        info('Preparing data')
         debug("Using data from #{config[:data_path]}")
 
-        tmpdata_dir = File.join(sandbox_path, "data")
+        tmpdata_dir = File.join(sandbox_path, 'data')
         FileUtils.mkdir_p(tmpdata_dir)
-        #FileUtils.cp_r(Dir.glob("#{config[:data_path]}/*"), tmpdata_dir)
         cp_r_with_filter(config[:data_path], tmpdata_dir, config[:salt_copy_filter])
       end
 
       def prepare_minion
-        info("Preparing salt-minion")
-
-        minion_config_content = <<-MINION_CONFIG.gsub(/^ {10}/, '')
-          state_top: top.sls
-
-          file_client: local
-
-          file_roots:
-           #{config[:salt_env]}:
-             - #{File.join(config[:root_path], config[:salt_file_root])}
-
-          pillar_roots:
-           #{config[:salt_env]}:
-             - #{File.join(config[:root_path], config[:salt_pillar_root])}
-        MINION_CONFIG
-
-        # create the temporary path for the salt-minion config file
-        debug("sandbox is #{sandbox_path}")
-        sandbox_minion_config_path = File.join(sandbox_path, config[:salt_minion_config])
-
-        # create the directory & drop the file in
-        FileUtils.mkdir_p(File.dirname(sandbox_minion_config_path))
-        File.open(sandbox_minion_config_path, "wb") do |file|
-          file.write(minion_config_content)
-        end
+        info('Preparing salt-minion')
 
-      end
-
-      def unsymbolize(obj)
-        return obj.inject({}){|memo,(k,v)| memo[k.to_s] =  unsymbolize(v); memo} if obj.is_a? Hash
-        return obj.inject([]){|memo,v| memo << unsymbolize(v); memo} if obj.is_a? Array
-        return obj
-      end
-
-      def prepare_state_top
-        info("Preparing state_top")
-
-        sandbox_state_top_path = File.join(sandbox_path, config[:salt_state_top])
-
-        if (config[:state_top_from_file] == false)
-          # use the top.sls embedded in .kitchen.yml
-
-          # we get a hash with all the keys converted to symbols, salt doesn't like this
-          # to convert all the keys back to strings again
-          state_top_content = unsymbolize(config[:state_top]).to_yaml
-          # .to_yaml will produce ! '*' for a key, Salt doesn't like this either
-          state_top_content.gsub!(/(!\s'\*')/, "'*'")
+        if config[:salt_minion_config_template]
+          minion_template = File.expand_path(config[:salt_minion_config_template], Kitchen::Config.new.kitchen_root)
         else
-          # load a top.sls from disk
-          state_top_content = File.read("top.sls")
+          minion_template = File.expand_path("./../minion.erb", __FILE__)
         end
 
-        # create the directory & drop the file in
-        FileUtils.mkdir_p(File.dirname(sandbox_state_top_path))
-        File.open(sandbox_state_top_path, "wb") do |file|
-          file.write(state_top_content)
+        if File.extname(minion_template) == ".erb"
+          minion_config_content = ERB.new(File.read(minion_template)).result(binding)
+        else
+          minion_config_content = File.read(minion_template)
         end
-      end
-
-      def prepare_pillars
-        info("Preparing pillars into #{config[:salt_pillar_root]}")
-        debug("Pillars Hash: #{config[:pillars]}")
-
-        return if config[:pillars].nil? && config[:'pillars-from-files'].nil?
 
-        # we get a hash with all the keys converted to symbols, salt doesn't like this
-        # to convert all the keys back to strings again
-        pillars = unsymbolize(config[:pillars])
-        debug("unsymbolized pillars hash: #{pillars}")
-
-        # write out each pillar (we get key/contents pairs)
-        pillars.each do |key,contents|
-
-          # convert the hash to yaml
-          pillar = contents.to_yaml
-
-          # .to_yaml will produce ! '*' for a key, Salt doesn't like this either
-          pillar.gsub!(/(!\s'\*')/, "'*'")
-
-          # generate the filename
-          sandbox_pillar_path = File.join(sandbox_path, config[:salt_pillar_root], key)
-
-          # create the directory where the pillar file will go
-          FileUtils.mkdir_p(File.dirname(sandbox_pillar_path))
-
-          debug("Rendered pillar yaml for #{key}:\n #{pillar}")
-          # create the directory & drop the file in
-          File.open(sandbox_pillar_path, "wb") do |file|
-            file.write(pillar)
-          end
-        end
+        # create the temporary path for the salt-minion config file
+        debug("sandbox is #{sandbox_path}")
+        sandbox_minion_config_path = File.join(sandbox_path, config[:salt_minion_config])
 
-        # copy the pillars from files straight across, as YAML.load/to_yaml and
-        # munge multiline strings
-        if !config[:'pillars-from-files'].nil?
-          external_pillars = unsymbolize(config[:'pillars-from-files'])
-          debug("external_pillars (unsymbolize): #{external_pillars}")
-          external_pillars.each do |key, srcfile|
-            debug("Copying external pillar: #{key}, #{srcfile}")
-            # generate the filename
-            sandbox_pillar_path = File.join(sandbox_path, config[:salt_pillar_root], key)
-            # create the directory where the pillar file will go
-            FileUtils.mkdir_p(File.dirname(sandbox_pillar_path))
-            # copy the file across
-            FileUtils.copy srcfile, sandbox_pillar_path
-          end
-        end
+        write_raw_file(sandbox_minion_config_path, minion_config_content)
       end
 
       def prepare_grains
@@ -383,101 +256,44 @@ module Kitchen
         return if config[:grains].nil?
 
         info("Preparing grains into #{config[:salt_config]}/grains")
-        # we get a hash with all the keys converted to symbols, salt doesn't like this
-        # to convert all the keys back to strings again we use unsymbolize
-        # then we convert the hash to yaml
-        grains = unsymbolize(config[:grains]).to_yaml
 
         # generate the filename
         sandbox_grains_path = File.join(sandbox_path, config[:salt_config], 'grains')
         debug("sandbox_grains_path: #{sandbox_grains_path}")
 
-        # create the directory where the pillar file will go
-        FileUtils.mkdir_p(File.dirname(sandbox_grains_path))
-
-        debug("Rendered grains yaml")
-        # create the directory & drop the file in
-        File.open(sandbox_grains_path, "wb") do |file|
-          file.write(grains)
-        end
+        write_hash_file(sandbox_grains_path, config[:grains])
       end
 
-      def prepare_formula(path, formula)
-        info("Preparing formula: #{formula} from #{path}")
-        debug("Using config #{config}")
-
-        formula_dir = File.join(sandbox_path, config[:salt_file_root], formula)
-        FileUtils.mkdir_p(formula_dir)
-        cp_r_with_filter(File.join(path, formula), formula_dir, config[:salt_copy_filter])
-
-        # copy across the _modules etc directories for python implementation
-        ['_modules', '_states', '_grains', '_renderers', '_returners'].each do |extrapath|
-          src = File.join(path, extrapath)
-
-          if (File.directory?(src))
-            debug("prepare_formula: #{src} exists, copying..")
-            extrapath_dir = File.join(sandbox_path, config[:salt_file_root], extrapath)
-            FileUtils.mkdir_p(extrapath_dir)
-            #FileUtils.cp_r(Dir.glob(File.join(src, "*")), extrapath_dir)
-            cp_r_with_filter(src, extrapath_dir, config[:salt_copy_filter])
-          else
-            debug("prepare_formula: #{src} doesn't exist, skipping.")
-          end
-        end
-      end
+      def prepare_dependencies
+        # upload scripts
+        sandbox_scripts_path = File.join(sandbox_path, config[:salt_config], 'scripts')
+        info("Preparing scripts into #{config[:salt_config]}/scripts")
 
-      def prepare_state_collection
-        info("Preparing state collection")
-        debug("Using config #{config}")
+        # PLACEHOLDER, git formulas might be fetched locally to temp and uploaded
 
-        if config[:collection_name].nil? and config[:formula].nil?
-          info("neither collection_name or formula have been set, assuming this is a pre-built collection")
-          config[:collection_name] = ""
-        else
-          if config[:collection_name].nil?
-            debug("collection_name not set, using #{config[:formula]}")
-            config[:collection_name] = config[:formula]
-          end
-        end
+        # setup spm
+        spm_repos = config[:vendor_repo].select{|x| x[:type]=='spm'}.each{|x| x[:url]}.map {|x| x[:url] }
+        spm_repos.each do |url|
+          id=url.gsub(/[htp:\/.]/,'')
+          spmreposd = File.join(sandbox_path, 'etc', 'salt', 'spm.repos.d')
+          repo_spec = File.join(spmreposd, 'spm.repo')
+          FileUtils.mkdir_p(spmreposd)
+          repo_content = '
+            #{id}:
+              url: #{url}
 
-        debug("sandbox_path = #{sandbox_path}")
-        debug("salt_file_root = #{config[:salt_file_root]}")
-        debug("collection_name = #{config[:collection_name]}")
-        collection_dir = File.join(sandbox_path, config[:salt_file_root], config[:collection_name])
-        FileUtils.mkdir_p(collection_dir)
-        cp_r_with_filter(config[:kitchen_root], collection_dir, config[:salt_copy_filter])
-
-      end
+          '
+          write_raw_file(repo_spec, repo_content)
+        end
 
-      def cp_r_with_filter(source_path, target_path, filter=[])
-        debug("cp_r_with_filter:source_path = #{source_path}")
-        debug("cp_r_with_filter:target_path = #{target_path}")
-        debug("cp_r_with_filter:filter = #{filter}")
-
-        Array(source_path).each do |source_path|
-          Find.find(source_path) do |source|
-            target = source.sub(/^#{source_path}/, target_path)
-            debug("cp_r_with_filter:source = #{source}")
-            debug("cp_r_with_filter:target = #{target}")
-            filtered = filter.include?(File.basename(source))
-            if File.directory? source
-              if filtered
-                debug("Found #{source} in #{filter}, pruning it from the Find")
-                Find.prune
-              end
-              FileUtils.mkdir target unless File.exists? target
-              if File.symlink? source
-                FileUtils.cp_r "#{source}/.", target
-              end
-            else
-              if filtered
-                debug("Found #{source} in #{filter}, not copying file")
-              else
-                FileUtils.copy source, target
-              end
-            end
-          end
+        # upload scripts
+        %w(formula-fetch.sh repository-setup.sh).each do |script|
+          write_raw_file(File.join(sandbox_path, script), File.read(File.expand_path("../#{script}", __FILE__)))
         end
+        dependencies_script = File.expand_path("./../dependencies.erb", __FILE__)
+        dependencies_content = ERB.new(File.read(dependencies_script)).result(binding)
+        write_raw_file(File.join(sandbox_path, 'dependencies.sh'), dependencies_content)
+
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-salt
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.25
 platform: ruby
 authors:
 - Simon McCartney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-24 00:00:00.000000000 Z
+date: 2017-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-kitchen
@@ -73,7 +73,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/kitchen-salt/pillars.rb
+- lib/kitchen-salt/states.rb
+- lib/kitchen-salt/util.rb
 - lib/kitchen-salt/version.rb
+- lib/kitchen/provisioner/dependencies.erb
+- lib/kitchen/provisioner/formula-fetch.sh
+- lib/kitchen/provisioner/install.erb
+- lib/kitchen/provisioner/install_win.erb
+- lib/kitchen/provisioner/minion.erb
+- lib/kitchen/provisioner/repository-setup.sh
 - lib/kitchen/provisioner/salt_solo.rb
 homepage: https://github.com//kitchen-salt
 licenses:
@@ -95,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: "[none]"
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: salt provisioner for test-kitchen