bmabey-vagrant 0.2.0

data/lib/vagrant/provisioners/base.rb

@@ -0,0 +1,29 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system. This has been abstracted out to provide
+    # support for multiple solutions such as Chef Solo, Chef Client, and
+    # Puppet.
+    class Base
+      include Vagrant::Util
+
+      # The environment which this is being provisioned in
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      # This is the method called to "prepare" the provisioner. This is called
+      # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
+      # This can be used to setup shared folders, forward ports, etc. Whatever is
+      # necessary on a "meta" level.
+      def prepare; end
+
+      # This is the method called to provision the system. This method
+      # is expected to do whatever necessary to provision the system (create files,
+      # SSH, etc.)
+      def provision!; end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -0,0 +1,103 @@
+module Vagrant
+  module Provisioners
+    # This class is a base class where the common functinality shared between
+    # chef-solo and chef-client provisioning are stored. This is **not an actual
+    # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      # This is the configuration which is available through `config.chef`
+      class ChefConfig < Vagrant::Config::Base
+        # Chef server specific config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+
+        # Chef solo specific config
+        attr_accessor :cookbooks_path
+        attr_accessor :role_path
+
+        # Shared config
+        attr_accessor :provisioning_path
+        attr_accessor :json
+
+        def initialize
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+
+          @cookbooks_path = "cookbooks"
+          @provisioning_path = "/tmp/vagrant-chef"
+          @json = {
+            :instance_role => "vagrant",
+            :run_list => ["recipe[vagrant_main]"]
+          }
+        end
+
+        # Returns the run list for the provisioning
+        def run_list
+          json[:run_list]
+        end
+
+        # Sets the run list to the specified value
+        def run_list=(value)
+          json[:run_list] = value
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+          run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+          run_list << name
+        end
+
+        def to_json
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          data = instance_variables_hash
+          data.delete(:json)
+          data.to_json
+        end
+      end
+
+      # Tell the Vagrant configure class about our custom configuration
+      Config.configures :chef, ChefConfig
+
+      def prepare
+        raise Actions::ActionException.new(:chef_base_invalid_provisioner)
+      end
+
+      def chown_provisioning_folder
+        logger.info "Setting permissions on chef provisioning folder..."
+        env.ssh.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{env.config.chef.provisioning_path}")
+          ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.chef.provisioning_path}")
+        end
+      end
+
+      def setup_json
+        logger.info "Generating chef JSON and uploading..."
+
+        # Set up initial configuration
+        data = {
+          :config => env.config,
+          :directory => env.config.vm.project_directory,
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(env.config.chef.json)
+
+        json = data.to_json
+
+        env.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_server.rb

@@ -0,0 +1,84 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-client, allowing provisioning
+    # with a chef server.
+    class ChefServer < Chef
+      def prepare
+        if env.config.chef.validation_key_path.nil?
+          raise Actions::ActionException.new(:chef_server_validation_key_required)
+        elsif !File.file?(validation_key_path)
+          raise Actions::ActionException.new(:chef_server_validation_key_doesnt_exist)
+        end
+
+        if env.config.chef.chef_server_url.nil?
+          raise Actions::ActionException.new(:chef_server_url_required)
+        end
+      end
+
+      def provision!
+        chown_provisioning_folder
+        create_client_key_folder
+        upload_validation_key
+        setup_json
+        setup_config
+        run_chef_client
+      end
+
+      def create_client_key_folder
+        logger.info "Creating folder to hold client key..."
+        path = Pathname.new(env.config.chef.client_key_path)
+
+        env.ssh.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        logger.info "Uploading chef client validation key..."
+        env.ssh.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def setup_config
+        solo_file = <<-solo
+log_level          :info
+log_location       STDOUT
+ssl_verify_mode    :verify_none
+chef_server_url    "#{env.config.chef.chef_server_url}"
+
+validation_client_name "#{env.config.chef.validation_client_name}"
+validation_key         "#{guest_validation_key_path}"
+client_key             "#{env.config.chef.client_key_path}"
+
+file_store_path    "/srv/chef/file_store"
+file_cache_path    "/srv/chef/cache"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true
+solo
+
+        logger.info "Uploading chef-client configuration script..."
+        env.ssh.upload!(StringIO.new(solo_file), File.join(env.config.chef.provisioning_path, "client.rb"))
+      end
+
+      def run_chef_client
+        logger.info "Running chef-client..."
+        env.ssh.execute do |ssh|
+          ssh.exec!("cd #{env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json") do |channel, data, stream|
+            # TODO: Very verbose. It would be easier to save the data and only show it during
+            # an error, or when verbosity level is set high
+            logger.info("#{stream}: #{data}")
+          end
+        end
+      end
+
+      def validation_key_path
+        File.expand_path(env.config.chef.validation_key_path, env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(@env.config.chef.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -0,0 +1,97 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-solo.
+    class ChefSolo < Chef
+      def prepare
+        share_cookbook_folders
+        share_role_folder
+      end
+
+      def provision!
+        chown_provisioning_folder
+        setup_json
+        setup_solo_config
+        run_chef_solo
+      end
+
+      def share_cookbook_folders
+        host_cookbook_paths.each_with_index do |cookbook, i|
+          env.config.vm.share_folder("vagrant-chef-solo-#{i}", cookbook_path(i), cookbook)
+        end
+      end
+
+      def share_role_folder
+          env.config.vm.share_folder("vagrant-chef-solo-roles", guest_role_path, host_role_path) if host_role_path
+      end
+
+      def setup_solo_config
+        solo_file = <<-solo
+file_cache_path "#{env.config.chef.provisioning_path}"
+cookbook_path #{cookbooks_path}
+solo
+        solo_file << "role_path #{role_path}" if host_role_path
+
+        logger.info "Uploading chef-solo configuration script..."
+        env.ssh.upload!(StringIO.new(solo_file), File.join(env.config.chef.provisioning_path, "solo.rb"))
+      end
+
+      def run_chef_solo
+        logger.info "Running chef-solo..."
+        env.ssh.execute do |ssh|
+          ssh.exec!("cd #{env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+            # TODO: Very verbose. It would be easier to save the data and only show it during
+            # an error, or when verbosity level is set high
+            logger.info("#{stream}: #{data}")
+          end
+        end
+      end
+
+      def host_cookbook_paths
+        cookbooks = env.config.chef.cookbooks_path
+        cookbooks = [cookbooks] unless cookbooks.is_a?(Array)
+        cookbooks.collect! { |cookbook| full_env_path(cookbook)}
+        return cookbooks
+      end
+
+      def cookbook_path(i)
+        full_provisioning_path "cookbooks-#{i}"
+      end
+
+      def host_role_path
+        env.config.chef.role_path
+      end
+
+      def role_path
+        guest_role_path.to_json
+      end
+
+      def cookbooks_path
+        result = []
+        host_cookbook_paths.each_with_index do |host_path, i|
+          result << cookbook_path(i)
+        end
+
+        # We're lucky that ruby's string and array syntax for strings is the
+        # same as JSON, so we can just convert to JSON here and use that
+        result = result.to_s if result.length == 1
+        result.to_json
+      end
+
+      private
+
+      def guest_role_path
+        full_provisioning_path "roles"
+      end
+
+      # TODO: Maybe these should be moved up so they can be reused...
+      def full_provisioning_path(relative_path)
+        File.join(env.config.chef.provisioning_path, relative_path)
+      end
+
+
+      def full_env_path(relative_path)
+        File.expand_path(relative_path, env.root_path)
+      end
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -0,0 +1,104 @@
+module Vagrant
+  # Manages SSH access to a specific environment. Allows an environment to
+  # replace the process with SSH itself, run a specific set of commands,
+  # upload files, or even check if a host is up.
+  class SSH
+    include Vagrant::Util
+
+    # Reference back up to the environment which this SSH object belongs
+    # to
+    attr_accessor :env
+
+    def initialize(environment)
+      @env = environment
+    end
+
+    # Connects to the environment's virtual machine, replacing the ruby
+    # process with an SSH process. This method optionally takes a hash
+    # of options which override the configuration values.
+    def connect(opts={})
+      options = {}
+      [:host, :username, :private_key_path].each do |param|
+        options[param] = opts[param] || env.config.ssh.send(param)
+      end
+
+      check_key_permissions(options[:private_key_path])
+      Kernel.exec "ssh -p #{port(opts)} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip
+    end
+
+    # Opens an SSH connection to this environment's virtual machine and yields
+    # a Net::SSH object which can be used to execute remote commands.
+    def execute(opts={})
+      Net::SSH.start(env.config.ssh.host,
+                     env.config[:ssh][:username],
+                     opts.merge( :port => port,
+                                 :keys => [env.config.ssh.private_key_path])) do |ssh|
+        yield ssh
+      end
+    end
+
+    # Uploads a file from `from` to `to`. `from` is expected to be a filename
+    # or StringIO, and `to` is expected to be a path. This method simply forwards
+    # the arguments to `Net::SCP#upload!` so view that for more information.
+    def upload!(from, to)
+      execute do |ssh|
+        scp = Net::SCP.new(ssh)
+        scp.upload!(from, to)
+      end
+    end
+
+    # Checks if this environment's machine is up (i.e. responding to SSH).
+    #
+    # @return [Boolean]
+    def up?
+      check_thread = Thread.new do
+        begin
+          Thread.current[:result] = false
+          execute(:timeout => env.config.ssh.timeout) do |ssh|
+            Thread.current[:result] = true
+          end
+        rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
+          # False, its defaulted above
+        end
+      end
+
+      check_thread.join(env.config.ssh.timeout)
+      return check_thread[:result]
+    rescue Net::SSH::AuthenticationFailed
+      error_and_exit(:vm_ssh_auth_failed)
+    end
+
+    # Checks the file permissions for the private key, resetting them
+    # if needed, or on failure erroring.
+    def check_key_permissions(key_path)
+      # TODO: This only works on unix based systems for now. Windows
+      # systems will need to be investigated further.
+      stat = File.stat(key_path)
+
+      if stat.owned? && file_perms(key_path) != "600"
+        logger.info "Permissions on private key incorrect, fixing..."
+        File.chmod(0600, key_path)
+
+        error_and_exit(:ssh_bad_permissions, :key_path => key_path) if file_perms(key_path) != "600"
+      end
+    rescue Errno::EPERM
+      # This shouldn't happen since we verify we own the file, but just
+      # in case.
+      error_and_exit(:ssh_bad_permissions, :key_path => key_path)
+    end
+
+    # Returns the file permissions of a given file. This is fairly unix specific
+    # and probably doesn't belong in this class. Will be refactored out later.
+    def file_perms(path)
+      perms = sprintf("%o", File.stat(path).mode)
+      perms.reverse[0..2].reverse
+    end
+
+    # Returns the port which is either given in the options hash or taken from
+    # the config by finding it in the forwarded ports hash based on the
+    # `config.ssh.forwarded_port_key`
+    def port(opts={})
+      opts[:port] || env.config.vm.forwarded_ports[env.config.ssh.forwarded_port_key][:hostport]
+    end
+  end
+end

data/lib/vagrant/util.rb

@@ -0,0 +1,51 @@
+module Vagrant
+  module Util
+    def self.included(base)
+      base.extend Vagrant::Util
+    end
+
+    def wrap_output
+      puts "====================================================================="
+      yield
+      puts "====================================================================="
+    end
+
+    def error_and_exit(key, data = {})
+      abort <<-error
+=====================================================================
+Vagrant experienced an error!
+
+#{Errors.error_string(key, data).chomp}
+=====================================================================
+error
+    end
+
+    def logger
+      Logger.singleton_logger
+    end
+  end
+
+  class Logger < ::Logger
+    @@singleton_logger = nil
+
+    class << self
+      def singleton_logger
+        # TODO: Buffer messages until config is loaded, then output them?
+        if Vagrant.config.loaded?
+          @@singleton_logger ||= Vagrant::Logger.new(Vagrant.config.vagrant.log_output)
+        else
+          Vagrant::Logger.new(nil)
+        end
+      end
+
+      def reset_logger!
+        @@singleton_logger = nil
+      end
+    end
+
+    def format_message(level, time, progname, msg)
+      "[#{level} #{time.strftime('%m-%d-%Y %X')}] Vagrant: #{msg}\n"
+    end
+  end
+end
+