tnargav 1.3.5 → 1.3.6

data/plugins/provisioners/salt/config.rb

@@ -0,0 +1,105 @@
+require "i18n"
+require "vagrant"
+
+module VagrantPlugins
+  module Salt
+    class Config < Vagrant.plugin("2", :config)
+
+      ## salty-vagrant options
+      attr_accessor :minion_config
+      attr_accessor :minion_key
+      attr_accessor :minion_pub
+      attr_accessor :master_config
+      attr_accessor :master_key
+      attr_accessor :master_pub
+      attr_accessor :run_highstate
+      attr_accessor :always_install
+      attr_accessor :bootstrap_script
+      attr_accessor :verbose
+      attr_accessor :seed_master
+      attr_reader   :pillar_data
+
+      ## bootstrap options
+      attr_accessor :temp_config_dir
+      attr_accessor :install_type
+      attr_accessor :install_args
+      attr_accessor :install_master
+      attr_accessor :install_syndic
+      attr_accessor :no_minion
+      attr_accessor :bootstrap_options
+
+      def initialize
+        @minion_config = UNSET_VALUE
+        @minion_key = UNSET_VALUE
+        @minion_pub = UNSET_VALUE
+        @master_config = UNSET_VALUE
+        @master_key = UNSET_VALUE
+        @master_pub = UNSET_VALUE
+        @run_highstate = UNSET_VALUE
+        @always_install = UNSET_VALUE
+        @bootstrap_script = UNSET_VALUE
+        @verbose = UNSET_VALUE
+        @seed_master = UNSET_VALUE
+        @pillar_data = UNSET_VALUE
+        @temp_config_dir = UNSET_VALUE
+        @install_type = UNSET_VALUE
+        @install_args = UNSET_VALUE
+        @install_master = UNSET_VALUE
+        @install_syndic = UNSET_VALUE
+        @no_minion = UNSET_VALUE
+        @bootstrap_options = UNSET_VALUE
+      end
+
+      def finalize!
+        @minion_config      = nil if @minion_config == UNSET_VALUE
+        @minion_key         = nil if @minion_key == UNSET_VALUE
+        @minion_pub         = nil if @minion_pub == UNSET_VALUE
+        @master_config      = nil if @master_config == UNSET_VALUE
+        @master_key         = nil if @master_key == UNSET_VALUE
+        @master_pub         = nil if @master_pub == UNSET_VALUE
+        @run_highstate      = nil if @run_highstate == UNSET_VALUE
+        @always_install     = nil if @always_install == UNSET_VALUE
+        @bootstrap_script   = nil if @bootstrap_script == UNSET_VALUE
+        @verbose            = nil if @verbose == UNSET_VALUE
+        @seed_master        = nil if @seed_master == UNSET_VALUE
+        @pillar_data        = {}  if @pillar_data == UNSET_VALUE
+        @temp_config_dir    = nil if @temp_config_dir == UNSET_VALUE
+        @install_type       = nil if @install_type == UNSET_VALUE
+        @install_args       = nil if @install_args == UNSET_VALUE
+        @install_master     = nil if @install_master == UNSET_VALUE
+        @install_syndic     = nil if @install_syndic == UNSET_VALUE
+        @no_minion          = nil if @no_minion == UNSET_VALUE
+        @bootstrap_options  = nil if @bootstrap_options == UNSET_VALUE
+
+      end
+
+      def pillar(data)
+        @pillar_data = {} if @pillar_data == UNSET_VALUE
+        @pillar_data.deep_merge!(data)
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        if @minion_key || @minion_pub
+          if !@minion_key || !@minion_pub
+            errors << @minion_pub
+          end
+        end
+
+        if @master_key && @master_pub
+          if !@minion_key && !@minion_pub
+            errors << I18n.t("salt.missing_key")
+          end
+        end
+
+        if @install_master && !@no_minion && !@seed_master && @run_highstate
+          errors << I18n.t("salt.must_accept_keys")
+        end
+
+        return {"salt" => errors}
+      end
+
+
+    end
+  end
+end

data/plugins/provisioners/salt/errors.rb

@@ -0,0 +1,11 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Salt
+    module Errors
+      class SaltError < Vagrant::Errors::VagrantError
+        error_namespace("salt")
+      end
+    end
+  end
+end

data/plugins/provisioners/salt/plugin.rb

@@ -0,0 +1,22 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Salt
+    class Plugin < Vagrant.plugin("2")
+      name "salt"
+      description <<-DESC
+      Provisions virtual machines using SaltStack
+      DESC
+
+      config(:salt, :provisioner) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      provisioner(:salt) do
+        require File.expand_path("../provisioner", __FILE__)
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/salt/provisioner.rb

@@ -0,0 +1,249 @@
+require 'json'
+
+module VagrantPlugins
+  module Salt
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        upload_configs
+        upload_keys
+        run_bootstrap_script
+        call_highstate
+      end
+
+      # Return a list of accepted keys
+      def keys(group='minions')
+        out = @machine.communicate.sudo("salt-key --out json") do |type, output|
+          begin
+            if type == :stdout
+              out = JSON::load(output)
+              break out[group]
+            end
+          end
+        end
+        return out
+      end
+
+      ## Utilities
+      def expanded_path(rel_path)
+        Pathname.new(rel_path).expand_path(@machine.env.root_path)
+      end
+
+      def binaries_found
+        ## Determine States, ie: install vs configure
+        desired_binaries = []
+        if !@config.no_minion
+          desired_binaries.push('salt-minion')
+          desired_binaries.push('salt-call')
+        end
+
+        if @config.install_master
+          desired_binaries.push('salt-master')
+        end
+
+        if @config.install_syndic
+          desired_binaries.push('salt-syndic')
+        end
+
+        found = true
+        for binary in desired_binaries
+          @machine.env.ui.info "Checking if %s is installed" % binary
+          if !@machine.communicate.test("which %s" % binary)
+            @machine.env.ui.info "%s was not found." % binary
+            found = false
+          else
+            @machine.env.ui.info "%s found" % binary
+          end
+        end
+
+        return found
+      end
+
+      def need_configure
+        @config.minion_config or @config.minion_key or @config.master_config or @config.master_key
+      end
+
+      def need_install
+        if @config.always_install
+          return true
+        else
+          return !binaries_found()
+        end
+      end
+
+      def temp_config_dir
+        return @config.temp_config_dir || "/tmp"
+      end
+
+      # Generates option string for bootstrap script
+      def bootstrap_options(install, configure, config_dir)
+        options = ""
+
+        ## Any extra options passed to bootstrap
+        if @config.bootstrap_options
+          options = "%s %s" % [options, @config.bootstrap_options]
+        end
+
+        if configure
+          options = "%s -c %s" % [options, config_dir]
+        end
+
+        if @config.seed_master and @config.install_master
+          seed_dir = "/tmp/minion-seed-keys"
+          @machine.communicate.sudo("mkdir -p -m777 #{seed_dir}")
+          @config.seed_master.each do |name, keyfile|
+            sourcepath = expanded_path(keyfile).to_s
+            dest = "#{seed_dir}/seed-#{name}.pub"
+            @machine.communicate.upload(sourcepath, dest)
+          end
+          options = "#{options} -k #{seed_dir}"
+        end
+
+        if configure and !install
+          options = "%s -C" % options
+        else
+
+          if @config.install_master
+            options = "%s -M" % options
+          end
+
+
+
+          if @config.install_syndic
+            options = "%s -S" % options
+          end
+
+          if @config.no_minion
+            options = "%s -N" % options
+          end
+
+          if @config.install_type
+            options = "%s %s" % [options, @config.install_type]
+          end
+
+          if @config.install_args
+            options = "%s %s" % [options, @config.install_args]
+          end
+        end
+
+        if @config.verbose
+          @machine.env.ui.info "Using Bootstrap Options: %s" % options
+        end
+
+        return options
+      end
+
+      ## Actions
+      # Get pillar string to pass with the salt command
+      def get_pillar
+        " pillar='#{@config.pillar_data.to_json}'" if !@config.pillar_data.empty?
+      end
+
+      # Copy master and minion configs to VM
+      def upload_configs
+        if @config.minion_config
+          @machine.env.ui.info "Copying salt minion config to vm."
+          @machine.communicate.upload(expanded_path(@config.minion_config).to_s, temp_config_dir + "/minion")
+        end
+
+        if @config.master_config
+          @machine.env.ui.info "Copying salt master config to vm."
+          @machine.communicate.upload(expanded_path(@config.master_config).to_s, temp_config_dir + "/master")
+        end
+      end
+
+      # Copy master and minion keys to VM
+      def upload_keys
+        if @config.minion_key and @config.minion_pub
+          @machine.env.ui.info "Uploading minion keys."
+          @machine.communicate.upload(expanded_path(@config.minion_key).to_s, temp_config_dir + "/minion.pem")
+          @machine.communicate.upload(expanded_path(@config.minion_pub).to_s, temp_config_dir + "/minion.pub")
+        end
+
+        if @config.master_key and @config.master_pub
+          @machine.env.ui.info "Uploading master keys."
+          @machine.communicate.upload(expanded_path(@config.master_key).to_s, temp_config_dir + "/master.pem")
+          @machine.communicate.upload(expanded_path(@config.master_pub).to_s, temp_config_dir + "/master.pub")
+        end
+      end
+
+      # Get bootstrap file location, bundled or custom
+      def get_bootstrap
+        if @config.bootstrap_script
+          bootstrap_abs_path = expanded_path(@config.bootstrap_script)
+        else
+          bootstrap_abs_path = Pathname.new("../bootstrap-salt.sh").expand_path(__FILE__)
+        end
+
+        return bootstrap_abs_path
+      end
+
+      # Determine if we are configure and/or installing, then do either
+      def run_bootstrap_script
+        install = need_install()
+        configure = need_configure()
+        config_dir = temp_config_dir()
+        options = bootstrap_options(install, configure, config_dir)
+
+        if configure or install
+          if configure and !install
+            @machine.env.ui.info "Salt binaries found. Configuring only."
+          else
+            @machine.env.ui.info "Bootstrapping Salt... (this may take a while)"
+          end
+
+          bootstrap_path = get_bootstrap
+          bootstrap_destination = File.join(config_dir, "bootstrap_salt.sh")
+          @machine.communicate.upload(bootstrap_path.to_s, bootstrap_destination)
+          @machine.communicate.sudo("chmod +x %s" % bootstrap_destination)
+          bootstrap = @machine.communicate.sudo("%s %s" % [bootstrap_destination, options]) do |type, data|
+            if data[0] == "\n"
+              # Remove any leading newline but not whitespace. If we wanted to
+              # remove newlines and whitespace we would have used data.lstrip
+              data = data[1..-1]
+            end
+            if @config.verbose
+              @machine.env.ui.info(data.rstrip)
+            end
+          end
+
+          if !bootstrap
+            raise Salt::Errors::SaltError, :bootstrap_failed
+          end
+
+          if configure and !install
+            @machine.env.ui.info "Salt successfully configured!"
+          elsif configure and install
+            @machine.env.ui.info "Salt successfully configured and installed!"
+          elsif !configure and install
+            @machine.env.ui.info "Salt successfully installed!"
+          end
+        else
+          @machine.env.ui.info "Salt did not need installing or configuring."
+        end
+      end
+
+      def call_highstate
+        if @config.run_highstate
+          @machine.env.ui.info "Calling state.highstate... (this may take a while)"
+          if @config.install_master
+            @machine.communicate.sudo("salt '*' saltutil.sync_all")
+            @machine.communicate.sudo("salt '*' state.highstate --verbose#{get_pillar}") do |type, data|
+              if @config.verbose
+                @machine.env.ui.info(data)
+              end
+            end
+          else
+            @machine.communicate.sudo("salt-call saltutil.sync_all")
+            @machine.communicate.sudo("salt-call state.highstate -l debug#{get_pillar}") do |type, data|
+              if @config.verbose
+                @machine.env.ui.info(data)
+              end
+            end
+          end
+        else
+          @machine.env.ui.info "run_highstate set to false. Not running state.highstate."
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/shell/config.rb

@@ -0,0 +1,65 @@
+require 'uri'
+
+module VagrantPlugins
+  module Shell
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :inline
+      attr_accessor :path
+      attr_accessor :upload_path
+      attr_accessor :args
+      attr_accessor :privileged
+
+      def initialize
+        @args        = UNSET_VALUE
+        @inline      = UNSET_VALUE
+        @path        = UNSET_VALUE
+        @upload_path = UNSET_VALUE
+        @privileged  = UNSET_VALUE
+      end
+
+      def finalize!
+        @args        = nil if @args == UNSET_VALUE
+        @inline      = nil if @inline == UNSET_VALUE
+        @path        = nil if @path == UNSET_VALUE
+        @upload_path = "/tmp/vagrant-shell" if @upload_path == UNSET_VALUE
+        @privileged  = true if @privileged == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        # Validate that the parameters are properly set
+        if path && inline
+          errors << I18n.t("vagrant.provisioners.shell.path_and_inline_set")
+        elsif !path && !inline
+          errors << I18n.t("vagrant.provisioners.shell.no_path_or_inline")
+        end
+
+        # If it is not an URL, we validate the existence of a script to upload
+        if path && ! remote?
+          expanded_path = Pathname.new(path).expand_path(machine.env.root_path)
+          if !expanded_path.file?
+            errors << I18n.t("vagrant.provisioners.shell.path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        # There needs to be a path to upload the script to
+        if !upload_path
+          errors << I18n.t("vagrant.provisioners.shell.upload_path_not_set")
+        end
+
+        # If there are args and its not a string, that is a problem
+        if args && !args.is_a?(String)
+          errors << I18n.t("vagrant.provisioners.shell.args_not_string")
+        end
+
+        { "shell provisioner" => errors }
+      end
+
+      def remote?
+        path =~ URI.regexp(["ftp", "http", "https"])
+      end
+    end
+  end
+end