vagrant-salt 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.DS_Store
+*.sublime-project
+*.sublime-workspace
+/pkg/

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.rst

@@ -0,0 +1,154 @@
+==============
+Salty Vagrant
+==============
+Provision `Vagrant`_ boxes using `Saltstack`_.
+
+Discussion and questions happen in ``#salt`` on Freenode IRC. ping ``akoumjian``.
+
+.. _`Vagrant`: http://www.vagrantup.com/
+.. _`Saltstack`: http://saltstack.org/
+.. _`Salt`: http://saltstack.org/
+
+Introduction
+============
+
+Just like Chef or Puppet, Salt can be used as a provisioning tool. 
+`Salty Vagrant`_ lets you use your salt state tree and a your minion config 
+file to automatically build your dev environment the same way you use salt 
+to deploy for other environments.
+
+.. _`Salty Vagrant`: https://github.com/akoumjian/salty-vagrant
+
+There are two different ways to use `Salty Vagrant`_. The simplest way uses 
+the salt minion in a masterless configuration. With this option you distribute 
+your state tree along with your Vagrantfile and a dev minion config. The 
+minion will bootstrap itself and apply all necessary states.
+
+The second method lets you specify a remote salt master, which assures that 
+the vagrant minion will always be able to fetch your most up to date state 
+tree. If you use a salt master, you will either need to manually accept 
+new vagrant minions on the master, or distribute preseeded keys along with 
+your vagrant files.
+
+Masterless (Quick Start)
+========================
+
+1. Install `Vagrant`_
+2. Install `Salty Vagrant`_ (``gem install vagrant-salt``)
+3. Get the Ubuntu 12.04 base box: ``vagrant box add precise64 http://files.vagrantup.com/precise64.box``
+4. Create/Update your ``Vagrantfile`` (Detailed in `Configuration`_)
+5. Place your salt state tree in ``salt/roots/salt``
+6. Place your minion config in ``salt/minion`` [#file_client]_
+7. Run ``vagrant up`` and you should be good to go.
+
+.. [#file_client] Make sure your minion config sets ``file_client: local`` for masterless
+
+Using Remote Salt Master
+========================
+
+If you are already using `Salt`_ for deployment, you can use your existing 
+master to provision your vagrant boxes as well. You will need to do one of the
+following:
+
+#. Manually accept the vagrant's minion key after it boots. [#accept_key]_
+#. Preseed the Vagrant box with minion keys pre-generated on the master
+
+.. [#accept_key] This is not recommended. If your developers need to destroy and rebuild their VM, you will have to repeat the process.
+
+Preseeding Vagrant Minion Keys
+------------------------------
+
+On the master, create the keypair and add the public key to the accepted minions 
+folder::
+
+    root@saltmaster# salt-key --gen-keys=[minion_id]
+    root@saltmaster# cp minion_id.pub /etc/salt/pki/minions/[minion_id]
+
+Replace ``[minion_id]`` with the id you would like to assign the minion. 
+
+Next you want to bundle the key pair along with your Vagrantfile, 
+the salt_provisioner.rb, and your minion config. The directory should look 
+something like this::
+
+    myvagrant/
+        Vagrantfile
+        salt/
+            minion.conf
+            key/
+                minion.pem
+                minion.pub
+
+You will need to determine your own secure method of transferring this 
+package. Leaking the minion's private key poses a security risk to your salt 
+network.
+
+The are two required settings for your ``minion.conf`` file::
+
+    master: [master_fqdn]
+    id: [minion_id]
+
+Make sure you use the same ``[minion_id]`` that you used on the master or 
+it will not match with the key.
+
+Create/Update your ``Vagrantfile`` per the example provided in the `Configuration`_ section.
+
+Finally, you should be able to run ``vagrant up`` and the salt should put your 
+vagrant minion in state.highstate.
+
+
+Configuration
+==============
+
+Your ``Vagrantfile`` should look roughly like this::
+
+    Vagrant::Config.run do |config|
+      config.vm.box = "precise64"
+      ## Use all the defaults:
+      config.vm.provision :salt do |salt|
+        salt.run_highstate = true
+
+        ## Optional Settings:
+        # salt.minion_config = "salt/minion.conf"
+
+        ## Only Use these with a masterless setup to
+        ## load your state tree:
+        # salt.salt_file_root_path = "salt/roots/salt"
+        # salt.salt_pillar_root_path = "salt/roots/pillar"
+
+        ## If you have a remote master setup, you can add
+        ## your preseeded minion key
+        # salt.master = true
+        # salt.minion_key = "salt/key/testing.pem"
+        # salt.minion_pub = "salt/key/testing.pub"
+      end
+    end
+
+Inside of your Vagrantfile, there are a few parameters you can assign 
+depending on whether you are running masterless or with a remote master.
+
+minion_config : "salt/minion.conf"
+    Path to your minion configuration file.
+
+minion_key : false
+    String path to your minion key. Only useful with ``master=true``
+
+minion_pub : false
+    String path to your minion public key. Only useful with ``master=true``
+
+master : false
+    Boolean whether or not you want to use a remote master. If set to false,
+    make sure your minion config file has ``file_client: local`` set.
+
+salt_file_root_path : "salt/roots/salt"
+    String path to your salt state tree. Only useful with ``master=false``.
+
+salt_file_root_guest_path : "/srv/salt"
+    Path to share the file root state tree on the VM. Only use with ``master=false``.
+
+salt_pillar_root_path : "salt/roots/pillar"
+    Path to share your pillar tree. Only useful with ``master=false``.
+
+salt_pillar_root_guest_path : "/srv/pillar"
+    Path on VM where pillar tree will be shared. Only use with ``master=true``
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'rubygems'
+require "bundler/gem_tasks"

data/example/.gitignore

@@ -0,0 +1 @@
+.vagrant

data/example/Vagrantfile

@@ -0,0 +1,23 @@
+require "../lib/vagrant-salt"
+
+Vagrant::Config.run do |config|
+  config.vm.box = "precise64"
+  ## Use all the defaults:
+  config.vm.provision :salt do |salt|
+    salt.run_highstate = true
+
+    ## Optional Settings:
+  	# salt.minion_config = "salt/minion.conf"
+
+  	## Only Use these with a masterless setup to
+  	## load your state tree:
+  	# salt.salt_file_root_path = "salt/roots/salt"
+  	# salt.salt_pillar_root_path = "salt/roots/pillar"
+
+  	## If you have a remote master setup, you can add
+  	## your preseeded minion key
+    # salt.master = true
+    # salt.minion_key = "salt/key/testing.pem"
+    # salt.minion_pub = "salt/key/testing.pub"
+  end
+end

data/example/salt/minion.conf

@@ -0,0 +1,220 @@
+# DO NOT MODIFY THIS FILE.  Copy it to: /etc/salt/minion
+##### Primary configuration settings #####
+##########################################
+# Set the location of the salt master server, if the master server cannot be
+# resolved, then the minion will fail to start.
+#master: salt
+
+# Set the port used by the master reply and authentication server
+#master_port: 4506
+
+# The user to run salt
+#user: root
+
+# The root directory prepended to these options: pki_dir, cachedir, log_file.
+#root_dir: /
+
+# The directory to store the pki information in
+#pki_dir: /etc/salt/pki
+
+# Explicitly declare the id for this minion to use, if left commented the id
+# will be the hostname as returned by the python call: socket.getfqdn()
+# Since salt uses detached ids it is possible to run multiple minions on the
+# same machine but with different ids, this can be useful for salt compute
+# clusters.
+#id: testing
+
+# Append a domain to a hostname in the event that it does not exist.  This is
+# usefule for systems where socket.getfqdn() does not actually result in a
+# FQDN (for instance, Solaris).
+#append_domain:
+
+# If the the connection to the server is interrupted, the minion will
+# attempt to reconnect. sub_timeout allows you to control the rate
+# of reconnection attempts (in seconds). To disable reconnects, set
+# this value to 0.
+#sub_timeout: 60
+
+# Where cache data goes
+#cachedir: /var/cache/salt
+
+# The minion can locally cache the return data from jobs sent to it, this
+# can be a good way to keep track of jobs the minion has executed
+# (on the minion side). By default this feature is disabled, to enable
+# set cache_jobs to True
+#cache_jobs: False
+
+# When waiting for a master to accept the minion's public key, salt will
+# continuously attempt to reconnect until successful. This is the time, in
+# seconds, between those reconnection attempts.
+#acceptance_wait_time = 10
+
+# When healing a dns_check is run, this is to make sure that the originally
+# resolved dns has not changed, if this is something that does not happen in
+# your environment then set this value to False.
+#dns_check: True
+
+
+#####   Minion module management     #####
+##########################################
+# Disable specific modules. This allows the admin to limit the level of
+# access the master has to the minion
+#disable_modules: [cmd,test]
+#disable_returners: []
+#
+# Modules can be loaded from arbitrary paths. This enables the easy deployment
+# of third party modules. Modules for returners and minions can be loaded.
+# Specify a list of extra directories to search for minion modules and
+# returners. These paths must be fully qualified!
+#module_dirs: []
+#returner_dirs: []
+#states_dirs: []
+#render_dirs: []
+#
+# A module provider can be statically overwritten or extended for the minion
+# via the providers option, in this case the default module will be
+# overwritten by the specified module. In this example the pkg module will
+# be provided by the yumpkg5 module instead of the system default.
+#
+# providers:
+#   pkg: yumpkg5
+#
+# Enable Cython modules searching and loading. (Default: False)
+#cython_enable: False
+
+#####    State Management Settings    #####
+###########################################
+# The state management system executes all of the state templates on the minion
+# to enable more granular control of system state management. The type of
+# template and serialization used for state management needs to be configured
+# on the minion, the default renderer is yaml_jinja. This is a yaml file
+# rendered from a jinja template, the available options are:
+# yaml_jinja
+# yaml_mako
+# json_jinja
+# json_mako
+#
+#renderer: yaml_jinja
+#
+# state_verbose allows for the data returned from the minion to be more
+# verbose. Normaly only states that fail or states that have changes are
+# returned, but setting state_verbose to True will return all states that
+# were checked
+#state_verbose: False
+#
+# autoload_dynamic_modules Turns on automatic loading of modules found in the
+# environments on the master. This is turned on by default, to turn of
+# autoloading modules when states run set this value to False
+#autoload_dynamic_modules: True
+#
+# clean_dynamic_modules keeps the dynamic modules on the minion in sync with
+# the dynamic modules on the master, this means that if a dynamic module is
+# not on the master it will be deleted from the minion. By default this is
+# enabled and can be disabled by changing this value to False
+#clean_dynamic_modules: True
+#
+# Normally the minion is not isolated to any single environment on the master
+# when running states, but the environment can be isolated on the minion side
+# by statically setting it. Remember that the recommended way to manage
+# environments is to issolate via the top file.
+#environment: None
+#
+# If using the local file directory, then the state top file name needs to be
+# defined, by default this is top.sls.
+#state_top: top.sls
+
+#####     File Directory Settings    #####
+##########################################
+# The Salt Minion can redirect all file server operations to a local directory,
+# this allows for the same state tree that is on the master to be used if
+# coppied completely onto the minion. This is a literal copy of the settings on
+# the master but used to reference a local directory on the minion.
+
+# Set the file client, the client defaults to looking on the master server for
+# files, but can be directed to look at the local file directory setting 
+# defined below by setting it to local.
+#file_client: local
+
+# The file directory works on environments passed to the minion, each environment
+# can have multiple root directories, the subdirectories in the multiple file
+# roots cannot match, otherwise the downloaded files will not be able to be
+# reliably ensured. A base environment is required to house the top file.
+# Example:
+# file_roots:
+#   base:
+#     - /srv/salt/
+#   dev:
+#     - /srv/salt/dev/services
+#     - /srv/salt/dev/states
+#   prod:
+#     - /srv/salt/prod/services
+#     - /srv/salt/prod/states
+#
+# Default:
+#file_roots:
+#  base:
+#    - /srv/salt
+
+# The hash_type is the hash to use when discovering the hash of a file in
+# the minion directory, the default is md5, but sha1, sha224, sha256, sha384
+# and sha512 are also supported.
+#hash_type: md5
+
+# The Salt pillar is searched for locally if file_client is set to local. If
+# this is the case, and pillar data is defined, then the pillar_roots need to
+# also be configured on the minion:
+#pillar_roots:
+#  base:
+#    - /srv/pillar
+
+######        Security settings       #####
+###########################################
+# Enable "open mode", this mode still maintains encryption, but turns off
+# authentication, this is only intended for highly secure environments or for
+# the situation where your keys end up in a bad state. If you run in open mode
+# you do so at your own risk!
+#open_mode: False
+
+
+######         Thread settings        #####
+###########################################
+# Disable multiprocessing support, by default when a minion receives a
+# publication a new process is spawned and the command is executed therein.
+#multiprocessing: True
+
+######         Logging settings       #####
+###########################################
+# The location of the minion log file
+#log_file: /var/log/salt/minion
+#
+# The level of messages to send to the log file.
+# One of 'info', 'quiet', 'critical', 'error', 'debug', 'warning'.
+# Default: 'warning'
+#log_level: warning
+#
+# Logger levels can be used to tweak specific loggers logging levels.
+# For example, if you want to have the salt library at the 'warning' level,
+# but you still wish to have 'salt.modules' at the 'debug' level:
+#   log_granular_levels: {
+#     'salt': 'warning',
+#     'salt.modules': 'debug'
+#   }
+#
+#log_granular_levels: {}
+
+######      Module configuration      #####
+###########################################
+# Salt allows for modules to be passed arbitrary configuration data, any data
+# passed here in valid yaml format will be passed on to the salt minion modules
+# for use. It is STRONGLY recommended that a naming convention be used in which
+# the module name is followed by a . and then the value. Also, all top level
+# data must be applied via the yaml dict construct, some examples:
+#
+# A simple value for the test module:
+#test.foo: foo
+#
+# A list for the test module:
+#test.bar: [baz,quo]
+#
+# A dict for the test module:
+#test.baz: {spam: sausage, cheese: bread}

data/lib/vagrant-salt/provisioner.rb

@@ -0,0 +1,141 @@
+module VagrantSalt
+  class Provisioner < Vagrant::Provisioners::Base
+    class Config < Vagrant::Config::Base
+      attr_accessor :minion_config
+      attr_accessor :minion_key
+      attr_accessor :minion_pub
+      attr_accessor :master
+      attr_accessor :run_highstate
+      attr_accessor :salt_file_root_path
+      attr_accessor :salt_file_root_guest_path
+      attr_accessor :salt_pillar_root_path
+      attr_accessor :salt_pillar_root_guest_path
+
+      def minion_config; @minion_config || "salt/minion.conf"; end
+      def minion_key; @minion_key || false; end
+      def minion_pub; @minion_pub || false; end
+      def master; @master || false; end
+      def run_highstate; @run_highstate || false; end
+      def salt_file_root_path; @salt_file_root_path || "salt/roots/salt"; end
+      def salt_file_root_guest_path; @salt_file_root_guest_path || "/srv/salt"; end
+      def salt_pillar_root_path; @salt_pillar_root_path || "salt/roots/pillar"; end
+      def salt_pillar_root_guest_path; @salt_pillar_root_guest_path || "/srv/pillar"; end
+
+      def expanded_path(root_path, rel_path)
+        Pathname.new(rel_path).expand_path(root_path)
+      end
+    end
+
+    def self.config_class
+      Config
+    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.master
+        env[:ui].info "Adding state tree folders."
+        @expanded_salt_file_root_path = config.expanded_path(env[:root_path], config.salt_file_root_path)
+        @expanded_salt_pillar_root_path = config.expanded_path(env[:root_path], config.salt_pillar_root_path)
+        share_salt_file_root_path
+        share_salt_pillar_root_path
+      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)
+      end
+    end
+
+    def share_salt_file_root_path
+      env[:ui].info "Sharing file root folder."
+      env[:vm].config.vm.share_folder("salt_file_root", config.salt_file_root_guest_path, @expanded_salt_file_root_path)
+    end
+
+    def share_salt_pillar_root_path
+      env[:ui].info "Sharing pillar root path."
+      env[:vm].config.vm.share_folder("salt_pillar_root", config.salt_pillar_root_guest_path, @expanded_salt_pillar_root_path)
+    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
+      end
+      env[:ui].info "Salt binaries not found."
+      return false
+    end
+
+    def add_salt_repo
+      env[:ui].info "Adding Salt PPA."
+      env[:vm].channel.sudo("apt-get -q -y install python-software-properties")
+      env[:vm].channel.sudo("add-apt-repository -y ppa:saltstack/salt")
+      env[:vm].channel.sudo("apt-get -q -y update")
+    end
+
+    def install_salt_minion
+      env[:ui].info "Installing salt minion."
+      env[:vm].channel.sudo("apt-get -q -y install salt-minion")
+    end
+
+    def accept_minion_key
+      env[:ui].info "Accepting minion key."
+      env[:vm].channel.sudo("salt-key -A")
+    end
+
+    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)
+        end
+      else
+        env[:ui].info "run_highstate set to false. Not running state.highstate."
+      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, "/tmp/minion")
+      env[:vm].channel.sudo("mv /tmp/minion /etc/salt/minion")
+    end
+
+    def upload_minion_keys
+      env[:ui].info "Uploading minion key."
+      env[:vm].channel.upload(@expanded_minion_key_path.to_s, "/tmp/minion.pem")
+      env[:vm].channel.sudo("mv /tmp/minion.pem /etc/salt/pki/minion.pem")
+      env[:vm].channel.upload(@expanded_minion_pub_path.to_s, "/tmp/minion.pub")
+      env[:vm].channel.sudo("mv /tmp/minion.pub /etc/salt/pki/minion.pub")
+    end
+
+    def provision!
+
+      verify_shared_folders([config.salt_file_root_guest_path, config.salt_pillar_root_guest_path])
+
+      if !salt_exists
+        add_salt_repo
+        install_salt_minion
+      end
+
+      upload_minion_config
+
+      if config.minion_key
+        upload_minion_keys
+      end
+
+      call_highstate
+    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}"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-salt.rb

@@ -0,0 +1,4 @@
+require "vagrant"
+require "vagrant-salt/provisioner"
+
+Vagrant.provisioners.register(:salt) { VagrantSalt::Provisioner }

data/lib/vagrant_init.rb

@@ -0,0 +1 @@
+require "vagrant-salt"

data/vagrant-salt.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "vagrant-salt"
+  s.version     = "0.1"
+  s.authors     = ["Alec Koumjian", "Kiall Mac Innes"]
+  s.email       = ["akoumjian@gmail.com", "kiall@managedit.ie"]
+  s.homepage    = "https://github.com/akoumjian/salty-vagrant"
+  s.summary     = %q{Vagrant Salt Stack provisioner plugin}
+  s.description = %q{Vagrant Salt Stack provisioner plugin}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "vagrant"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: vagrant-salt
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Alec Koumjian
+- Kiall Mac Innes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: vagrant
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Vagrant Salt Stack provisioner plugin
+email: 
+- akoumjian@gmail.com
+- kiall@managedit.ie
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rst
+- Rakefile
+- example/.gitignore
+- example/Vagrantfile
+- example/salt/key/KEYPAIR_GOES_HERE
+- example/salt/minion.conf
+- example/salt/roots/pillar/top.sls
+- example/salt/roots/salt/top.sls
+- lib/vagrant-salt.rb
+- lib/vagrant-salt/provisioner.rb
+- lib/vagrant_init.rb
+- vagrant-salt.gemspec
+homepage: https://github.com/akoumjian/salty-vagrant
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Vagrant Salt Stack provisioner plugin
+test_files: []
+