vagrant-salt 0.3.2 → 0.4.0

data/lib/vagrant-salt/provisioner.rb

@@ -1,134 +1,241 @@
-module VagrantSalt
-  class Provisioner < Vagrant::Provisioners::Base
-    class Config < Vagrant::Config::Base
-      attr_accessor :minion_config
-      attr_accessor :temp_config_dir
-      attr_accessor :minion_key
-      attr_accessor :minion_pub
-      attr_accessor :run_highstate
-      attr_accessor :salt_install_type
-      attr_accessor :salt_install_args
-
-      def minion_config; @minion_config || "salt/minion.conf"; end
-      def temp_config_dir; @temp_config_dir || "/tmp/"; end
-      def minion_key; @minion_key || false; end
-      def minion_pub; @minion_pub || false; end
-      def run_highstate; @run_highstate || false; end
-      def salt_install_type; @salt_install_type || ''; end
-      def salt_install_args; @salt_install_args || ''; end
-
-
-      def expanded_path(root_path, rel_path)
-        Pathname.new(rel_path).expand_path(root_path)
+module VagrantPlugins
+  module Salt
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+
+
+      def provision
+        upload_configs
+        upload_keys
+        run_bootstrap_script
+        accept_keys
+        call_highstate
       end
 
-      def bootstrap_options
-        options = ''
-        if temp_config_dir
-          options = options + '-c %s' % temp_config_dir
-        end
-        options = options + ' %s %s' % [salt_install_type, salt_install_args]
-        return options
+      ## Utilities
+      def expanded_path(rel_path)
+        Pathname.new(rel_path).expand_path(@machine.env.root_path)
       end
-    end
 
-    def self.config_class
-      Config
-    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
 
-    def prepare
-      # Calculate the paths we're going to use based on the environment
-      @expanded_minion_config_path = config.expanded_path(env[:root_path], config.minion_config)
+        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
 
-      if config.minion_key
-        @expanded_minion_key_path = config.expanded_path(env[:root_path], config.minion_key)
-        @expanded_minion_pub_path = config.expanded_path(env[:root_path], config.minion_pub)
+        return found
       end
-    end
 
-    def salt_exists
-      env[:ui].info "Checking for salt binaries..."
-      if env[:vm].channel.test("which salt-call") and
-         env[:vm].channel.test("which salt-minion")
-        return true
+      def need_configure
+        @config.minion_config or @config.minion_key
       end
-      env[:ui].info "Salt binaries not found."
-      return false
-    end
 
-    def bootstrap_salt_minion
-      env[:ui].info "Bootstrapping salt-minion on VM..."
-      @expanded_bootstrap_script_path = config.expanded_path(__FILE__, "../../../scripts/bootstrap-salt-minion.sh")
-      env[:vm].channel.upload(@expanded_bootstrap_script_path.to_s, "/tmp/bootstrap-salt-minion.sh")
-      env[:vm].channel.sudo("chmod +x /tmp/bootstrap-salt-minion.sh")
-      bootstrap = env[:vm].channel.sudo("/tmp/bootstrap-salt-minion.sh %s" % config.bootstrap_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
-        env[:ui].info(data.rstrip)
+      def need_install
+        if @config.always_install
+          return true
+        else
+          return !binaries_found()
+        end
       end
-      if !bootstrap
-        raise "Failed to bootstrap salt-minion on VM, see /var/log/bootstrap-salt-minion.log on VM."
+
+      def temp_config_dir
+        return @config.temp_config_dir || "/tmp"
       end
-      env[:ui].info "Salt binaries installed on VM."
-    end
 
-    def accept_minion_key
-      env[:ui].info "Accepting minion key."
-      env[:vm].channel.sudo("salt-key -A")
-    end
+      # Generates option string for bootstrap script
+      def bootstrap_options(install, configure, config_dir)
+        options = ""
 
-    def call_highstate
-      if config.run_highstate
-        env[:ui].info "Calling state.highstate"
-        env[:vm].channel.sudo("salt-call saltutil.sync_all")
-        env[:vm].channel.sudo("salt-call state.highstate") do |type, data|
-          env[:ui].info(data)
+        ## Any extra options passed to bootstrap
+        if @config.bootstrap_options
+          options = "%s %s" % [options, @config.bootstrap_options]
         end
-      else
-        env[:ui].info "run_highstate set to false. Not running state.highstate."
+
+        if configure
+          options = "%s -c %s" % [options, config_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
-    end
 
-    def upload_minion_config
-      env[:ui].info "Copying salt minion config to vm."
-      env[:vm].channel.upload(@expanded_minion_config_path.to_s, config.temp_config_dir + "minion")
-    end
 
-    def upload_minion_keys
-      env[:ui].info "Uploading minion key."
-      env[:vm].channel.upload(@expanded_minion_key_path.to_s, config.temp_config_dir + "minion.pem")
-      env[:vm].channel.upload(@expanded_minion_pub_path.to_s, config.temp_config_dir + "minion.pub")
-    end
+      ## Actions
+      # 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
 
-    def provision!
+        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
 
-      upload_minion_config
+      # 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.minion_key
-        upload_minion_keys
+        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
 
-      if !salt_exists
-        bootstrap_salt_minion
+      # 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("../../../scripts/bootstrap-salt.sh").expand_path(__FILE__)
+        end
+        return bootstrap_abs_path
       end
 
-      call_highstate
-    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 verify_shared_folders(folders)
-      folders.each do |folder|
-        # @logger.debug("Checking for shared folder: #{folder}")
-        env[:ui].info "Checking shared folder #{folder}"
-        if !env[:vm].channel.test("test -d #{folder}")
-          raise "Missing folder #{folder}"
+      def accept_keys
+        if @config.accept_keys
+          if !@machine.communicate.test("which salt-key")
+            @machine.env.ui.info "Salt-key not installed!"
+          else
+            @machine.env.ui.info "Waiting for minion key..."
+            key_staged = false
+            attempts = 0
+            while !key_staged
+              attempts += 1 
+              @machine.communicate.sudo("salt-key -l pre | wc -l") do |type, output|
+                begin
+                  output = Integer(output)
+                  if output > 1
+                    key_staged = true
+                  end
+                rescue
+                end
+              end
+              sleep 1
+              if attempts > 10
+                raise Salt::Errors::SaltError, :not_received_minion_key
+              end
+            end
+
+            @machine.env.ui.info "Accepting minion key."
+            @machine.communicate.sudo("salt-key -A")
+          end
         end
       end
-    end
-  end
 
-end
+      def call_highstate
+        if @config.run_highstate
+          @machine.env.ui.info "Calling state.highstate... (this may take a while)"
+          @machine.communicate.sudo("salt-call saltutil.sync_all")
+          @machine.communicate.sudo("salt-call state.highstate -l debug") do |type, data|
+            if @config.verbose
+              @machine.env.ui.info(data)
+            end
+          end
+        else
+          @machine.env.ui.info "run_highstate set to false. Not running state.highstate."
+        end
+      end
 
-# vim: fenc=utf-8 spell spl=en cc=80 sts=2 sw=2 et
+    end
+  end
+end

data/lib/vagrant-salt/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Salt
+    VERSION = "0.4.0"
+  end
+end

data/scripts/.travis.yml

@@ -0,0 +1,16 @@
+before_install:
+  - "if [[ $TRAVIS_PYTHON_VERSION == '2.6' ]]; then sudo pip install unittest2; fi"
+  - sudo pip install unittest-xml-reporting
+  - sudo apt-get remove -y -o DPkg::Options::=--force-confold --purge libzmq3
+  - sudo apt-get autoremove -y -o DPkg::Options::=--force-confold --purge
+  - sudo ls -lah /etc/apt/sources.list.d/
+  - sudo rm -f /etc/apt/sources.list.d/travis_ci_zeromq3-source.list
+
+script:
+  - BS_ECHO_DEBUG=1 sudo -E python tests/runtests.py -vv
+
+notifications:
+  irc:
+    channels: "irc.freenode.org#salt-devel"
+    on_success: change
+    on_failure: change

data/scripts/ChangeLog

@@ -0,0 +1,39 @@
+Version 1.5.2:
+	* Fix issue with travis testing(it installs it's own ZeroMQ3 lib
+	* Allow setting the debug output from an environment variable
+	* Fix an escape issue in the `printf` calls used in our echo calls
+	* Don't overwrite files(config, init.d, etc). Use a specific flag to
+	force overwrites.
+	* Distro Support Fixed:
+		* Ubuntu daily installs.
+	* Distro Support Added:
+		* Trisquel 6.0 (Ubuntu 12.04)
+
+Version 1.5.1:
+	* Improved unittesting.
+	* Starting daemons.
+	* Make sure that daemons are really running.
+	* For the users to make the choice if installing from PIP(if required
+	since there aren't system pacakges).
+	* Fixed salt's git cloning when the salt git tree is already present on
+	the system.
+	* Distro Support Fixed:
+		* Debian 6
+		* Ubuntu 12.10
+		* CentOS
+	* Distro Support Added:
+		* SuSE 11 SP1/11 SP2
+		* OpenSUSE 12.x
+
+Version 1.5:
+	* First stable version of the script
+	* Support for:
+		* Ubuntu 10.x/11.x/12.x
+		* Debian 6.x
+		* CentOS 5/6
+		* Red Hat 5/6
+		* Red Hat Enterprise 5/6
+		* Fedora
+		* Arch
+		* SmartOS
+		* FreeBSD 9.0

data/scripts/LICENSE

@@ -0,0 +1,16 @@
+   Salt Bootstrap - Generic Salt Bootstrap Script
+
+   Copyright 2012-2013 Salt Stack (saltstack.org)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/scripts/README.rst

@@ -1,12 +1,12 @@
+==================
 Bootstrapping Salt
 ==================
 
-Before `Salt`_ can be used for provisioning on the desired machine, the 
-binaries need to be installed. Since `Salt`_ supports many different 
-distributions and versions of operating systems, the `Salt`_ installation 
-process is handled by this shell script ``bootstrap-salt-minion.sh``.  This 
-script runs through a series of checks to determine operating system type and 
-version to then install the `Salt`_ binaries using the appropriate methods.
+Before `Salt`_ can be used for provisioning on the desired machine, the binaries need to be 
+installed. Since `Salt`_ supports many different distributions and versions of operating systems, 
+the `Salt`_ installation process is handled by this shell script ``bootstrap-salt.sh``.  This 
+script runs through a series of checks to determine operating system type and version to then 
+install the `Salt`_ binaries using the appropriate methods.
 
 
 One Line Bootstrap
@@ -18,15 +18,24 @@ For example, using ``curl`` to install latest git:
 
 .. code:: console
 
-  curl -L http://bootstrap.saltstack.org | sudo sh -s git develop
+  curl -L http://bootstrap.saltstack.org | sudo sh -s -- git develop
+
+
+If you have certificate issues using ``curl``, try the following:
+
+.. code:: console 
+
+  curl --insecure -L http://bootstrap.saltstack.org | sudo sh -s -- git develop
 
 
-Or, using ``wget`` to install your distribution's stable packages:
+
+Using ``wget`` to install your distribution's stable packages:
 
 .. code:: console
 
   wget -O - http://bootstrap.saltstack.org | sudo sh
 
+
 If you have certificate issues using ``wget`` try the following:
 
 .. code:: console
@@ -34,11 +43,36 @@ If you have certificate issues using ``wget`` try the following:
   wget --no-check-certificate -O - http://bootstrap.saltstack.org | sudo sh
 
 
-If you already have python installed, then it's as easy as:
+
+If you already have python installed, ``python 2.6``, then it's as easy as:
+
+.. code:: console
+
+  python -m urllib "http://bootstrap.saltstack.org" | sudo sh -s -- git develop
+
+
+All python versions should support the following one liner:
+
+.. code:: console
+
+  python -c 'import urllib; print urllib.urlopen("http://bootstrap.saltstack.org").read()' | \
+  sudo  sh -s -- git develop
+
+
+On a FreeBSD base system you usually don't have either of the above binaries available. You **do** 
+have ``fetch`` available though:
+
+.. code:: console
+
+  fetch -o - http://bootstrap.saltstack.org | sudo sh
+
+
+
+If all you want is to install a ``salt-master`` using latest git:
 
 .. code:: console
 
-  python -m urllib "http://bootstrap.saltstack.org" | sudo sh -s git develop
+  curl -L http://bootstrap.saltstack.org | sudo sh -s -- -M -N git develop
 
 
 
@@ -50,54 +84,81 @@ In order to install salt for a distribution you need to define:
 
 .. code:: bash
 
-  install_<distro>_<distro_version>_<install_type>_deps
-  install_<distro>_<distro_version>_deps
+  install_<distro>_<major_version>_<install_type>_deps
+  install_<distro>_<major_version>_<minor_version>_<install_type>_deps
+  install_<distro>_<major_version>_deps
+  install_<distro>_<major_version>_<minor_version>_deps
   install_<distro>_<install_type>_deps
   install_<distro>_deps
 
 
-2. To install salt, which, of course, is required, one of:
+2. Optionally, define a minion configuration function, which will be called if the 
+   ``-c|config-dir`` option is passed. One of:
 
 .. code:: bash
 
-  install_<distro>_<distro_version>_<install_type>
-  install_<distro>_<install_type>
+  config_<distro>_<major_version>_<install_type>_salt
+  config_<distro>_<major_version>_<minor_version>_<install_type>_salt
+  config_<distro>_<major_version>_salt
+  config_<distro>_<major_version>_<minor_version>_salt
+  config_<distro>_<install_type>_salt
+  config_<distro>_salt
+  config_salt [THIS ONE IS ALREADY DEFINED AS THE DEFAULT]
 
 
-3. Optionally, define a minion configuration function, which will be called if 
-   the ``-c|config-dir`` option is passed. One of:
+3. To install salt, which, of course, is required, one of:
 
 .. code:: bash
 
-  config_<distro>_<distro_version>_<install_type>_minion
-  config_<distro>_<distro_version>_minion
-  config_<distro>_<install_type>_minion
-  config_<distro>_minion
-  config_minion [THIS ONE IS ALREADY DEFINED AS THE DEFAULT]
+  install_<distro>_<major_version>_<install_type>
+  install_<distro>_<major_version>_<minor_version>_<install_type>
+  install_<distro>_<install_type>
 
 
-4. Also optionally, define a post install function, one of:
+4. Optionally, define a post install function, one of:
 
 .. code:: bash
 
-  install_<distro>_<distro_versions>_<install_type>_post
-  install_<distro>_<distro_versions>_post
+  install_<distro>_<major_version>_<install_type>_post
+  install_<distro>_<major_version>_<minor_version>_<install_type>_post
+  install_<distro>_<major_version>_post
+  install_<distro>_<major_version>_<minor_version>_post
   install_<distro>_<install_type>_post
   install_<distro>_post
 
 
+5. Optionally, define a start daemons function, one of:
+
+.. code:: bash
+
+  install_<distro>_<major_version>_<install_type>_restart_daemons
+  install_<distro>_<major_version>_<minor_version>_<install_type>_restart_daemons
+  install_<distro>_<major_version>_restart_daemons
+  install_<distro>_<major_version>_<minor_version>_restart_daemons
+  install_<distro>_<install_type>_restart_daemons
+  install_<distro>_restart_daemons
+
+
+.. admonition:: Attention!
+
+  The start daemons function should be able to restart any daemons which are running, or start if 
+  they're not running.
+
+
+----
+
 Below is an example for Ubuntu Oneiric:
 
 .. code:: bash
 
-  install_ubuntu_1110_deps() {
+  install_ubuntu_11_10_deps() {
       apt-get update
       apt-get -y install python-software-properties
       add-apt-repository -y 'deb http://us.archive.ubuntu.com/ubuntu/ oneiric universe'
       add-apt-repository -y ppa:saltstack/salt
   }
 
-  install_ubuntu_1110_post() {
+  install_ubuntu_11_10_post() {
       add-apt-repository -y --remove 'deb http://us.archive.ubuntu.com/ubuntu/ oneiric universe'
   }
 
@@ -105,24 +166,52 @@ Below is an example for Ubuntu Oneiric:
       apt-get -y install salt-minion
   }
 
+  install_ubuntu_restart_daemons() {
+      for fname in minion master syndic; do
+
+          # Skip if not meant to be installed
+          [ $fname = "minion" ] && [ $INSTALL_MINION -eq $BS_FALSE ] && continue
+          [ $fname = "master" ] && [ $INSTALL_MASTER -eq $BS_FALSE ] && continue
+          [ $fname = "syndic" ] && [ $INSTALL_SYNDIC -eq $BS_FALSE ] && continue
+
+          if [ -f /sbin/initctl ]; then
+              # We have upstart support
+              /sbin/initctl status salt-$fname > /dev/null 2>&1
+              if [ $? -eq 0 ]; then
+                  # upstart knows about this service, let's stop and start it.
+                  # We could restart but earlier versions of the upstart script
+                  # did not support restart, so, it's safer this way
+                  /sbin/initctl stop salt-$fname > /dev/null 2>&1
+                  /sbin/initctl start salt-$fname > /dev/null 2>&1
+                  [ $? -eq 0 ] && continue
+                  # We failed to start the service, let's test the SysV code bellow
+              fi
+          fi
+          /etc/init.d/salt-$fname stop > /dev/null 2>&1
+          /etc/init.d/salt-$fname start &
+      done
+  }
+
 
-Since there is no ``install_ubuntu_1110_stable()`` it defaults to the 
-unspecified version script.
+Since there is no ``install_ubuntu_11_10_stable()`` it defaults to the unspecified version script.
 
-The bootstrapping script must be plain POSIX sh only, **not** bash or another 
-shell script. By design the targeting for each operating system and version is 
-very specific. Assumptions of supported versions or variants should not be 
-made, to avoid failed or broken installations.
+The bootstrapping script must be plain POSIX sh only, **not** bash or another shell script. By 
+design the targeting for each operating system and version is very specific. Assumptions of 
+supported versions or variants should not be made, to avoid failed or broken installations.
 
 Supported Operating Systems
 ---------------------------
 - Ubuntu 10.x/11.x/12.x
 - Debian 6.x
-- CentOS 6.3
+- CentOS 5/6
+- Red Hat 5/6
+- Red Hat Enterprise 5/6
 - Fedora
 - Arch
 - FreeBSD 9.0
-
+- SmartOS
+- SuSE 11 SP1/11 SP2
+- OpenSUSE 12.x