vagrant 0.2.0 → 0.3.0

data/lib/vagrant/environment.rb

@@ -0,0 +1,259 @@
+module Vagrant
+  # Represents a single Vagrant environment. This class is responsible
+  # for loading all of the Vagrantfile's for the given environment and
+  # storing references to the various instances.
+  class Environment
+    ROOTFILE_NAME = "Vagrantfile"
+    HOME_SUBDIRS = ["tmp", "boxes"]
+
+    include Util
+
+    attr_accessor :cwd
+    attr_reader :root_path
+    attr_reader :config
+    attr_reader :box
+    attr_accessor :vm
+    attr_reader :ssh
+    attr_reader :active_list
+    attr_reader :commands
+
+    #---------------------------------------------------------------
+    # Class Methods
+    #---------------------------------------------------------------
+    class <<self
+      # Loads and returns an environment given a specific working
+      # directory. If a working directory is not given, it will default
+      # to the pwd.
+      def load!(cwd=nil)
+        Environment.new(cwd).load!
+      end
+
+      # Verifies that VirtualBox is installed and that the version of
+      # VirtualBox installed is high enough. Also verifies that the
+      # configuration path is properly set.
+      def check_virtualbox!
+        version = VirtualBox.version
+        if version.nil?
+          error_and_exit(:virtualbox_not_detected)
+        elsif version.to_f < 3.1
+          error_and_exit(:virtualbox_invalid_version, :version => version.to_s)
+        end
+      end
+    end
+
+    def initialize(cwd=nil)
+      @cwd = cwd
+    end
+
+    #---------------------------------------------------------------
+    # Path Helpers
+    #---------------------------------------------------------------
+
+    # Specifies the "current working directory" for this environment.
+    # This is vital in determining the root path and therefore the
+    # dotfile, rootpath vagrantfile, etc. This defaults to the
+    # actual cwd (`Dir.pwd`).
+    def cwd
+      @cwd || Dir.pwd
+    end
+
+    # The path to the `dotfile`, which contains the persisted UUID of
+    # the VM if it exists.
+    def dotfile_path
+      File.join(root_path, config.vagrant.dotfile_name)
+    end
+
+    # The path to the home directory, which is usually in `~/.vagrant/~
+    def home_path
+      config ? config.vagrant.home : nil
+    end
+
+    # The path to the Vagrant tmp directory
+    def tmp_path
+      File.join(home_path, "tmp")
+    end
+
+    # The path to the Vagrant boxes directory
+    def boxes_path
+      File.join(home_path, "boxes")
+    end
+
+    #---------------------------------------------------------------
+    # Load Methods
+    #---------------------------------------------------------------
+
+    # Loads this entire environment, setting up the instance variables
+    # such as `vm`, `config`, etc. on this environment. The order this
+    # method calls its other methods is very particular.
+    def load!
+      load_root_path!
+      load_config!
+      load_home_directory!
+      load_box!
+      load_config!
+      self.class.check_virtualbox!
+      load_vm!
+      load_ssh!
+      load_active_list!
+      load_commands!
+      self
+    end
+
+    # Loads the root path of this environment, given the starting
+    # directory (the "cwd" of this environment for lack of better words).
+    # This method allows an environment in `/foo` to be detected from
+    # `/foo/bar` (similar to how git works in subdirectories)
+    def load_root_path!(path=nil)
+      path = Pathname.new(File.expand_path(path || cwd))
+
+      # Stop if we're at the root.
+      return false if path.root?
+
+      file = "#{path}/#{ROOTFILE_NAME}"
+      if File.exist?(file)
+        @root_path = path.to_s
+        return true
+      end
+
+      load_root_path!(path.parent)
+    end
+
+    # Loads this environment's configuration and stores it in the {config}
+    # variable. The configuration loaded by this method is specified to
+    # this environment, meaning that it will use the given root directory
+    # to load the Vagrantfile into that context.
+    def load_config!
+      # Prepare load paths for config files
+      load_paths = [File.join(PROJECT_ROOT, "config", "default.rb")]
+      load_paths << File.join(box.directory, ROOTFILE_NAME) if box
+      load_paths << File.join(home_path, ROOTFILE_NAME) if home_path
+      load_paths << File.join(root_path, ROOTFILE_NAME) if root_path
+
+      # Clear out the old data
+      Config.reset!(self)
+
+      # Load each of the config files in order
+      load_paths.each do |path|
+        if File.exist?(path)
+          logger.info "Loading config from #{path}..."
+          load path
+        end
+      end
+
+      # Execute the configuration stack and store the result
+      @config = Config.execute!
+    end
+
+    # Loads the home directory path and creates the necessary subdirectories
+    # within the home directory if they're not already created.
+    def load_home_directory!
+      # Setup the array of necessary home directories
+      dirs = HOME_SUBDIRS.collect { |subdir| File.join(home_path, subdir) }
+      dirs.unshift(home_path)
+
+      # Go through each required directory, creating it if it doesn't exist
+      dirs.each do |dir|
+        next if File.directory?(dir)
+
+        logger.info "Creating home directory since it doesn't exist: #{dir}"
+        FileUtils.mkdir_p(dir)
+      end
+    end
+
+    # Loads the specified box for this environment.
+    def load_box!
+      return unless root_path
+
+      @box = Box.find(self, config.vm.box) if config.vm.box
+    end
+
+    # Loads the persisted VM (if it exists) for this environment.
+    def load_vm!
+      return if !root_path || !File.file?(dotfile_path)
+
+      File.open(dotfile_path) do |f|
+        @vm = Vagrant::VM.find(f.read)
+        @vm.env = self if @vm
+      end
+    rescue Errno::ENOENT
+      @vm = nil
+    end
+
+    # Loads/initializes the SSH object
+    def load_ssh!
+      @ssh = SSH.new(self)
+    end
+
+    # Loads the activelist for this environment
+    def load_active_list!
+      @active_list = ActiveList.new(self)
+    end
+
+    # Loads the instance of {Command} for this environment. This allows
+    # users of the instance to run commands such as "up" "down" etc. in
+    # the context of this environment.
+    def load_commands!
+      @commands = Command.new(self)
+    end
+
+    #---------------------------------------------------------------
+    # Methods to manage VM
+    #---------------------------------------------------------------
+
+    # Sets the VM to a new VM. This is not too useful but is used
+    # in {Command.up}. This will very likely be refactored at a later
+    # time.
+    def create_vm
+      @vm = VM.new
+      @vm.env = self
+      @vm
+    end
+
+    # Persists this environment's VM to the dotfile so it can be
+    # re-loaded at a later time.
+    def persist_vm
+      # Save to the dotfile for this project
+      File.open(dotfile_path, 'w+') do |f|
+        f.write(vm.uuid)
+      end
+
+      # Also add to the global store
+      active_list.add(vm)
+    end
+
+    # Removes this environment's VM from the dotfile.
+    def depersist_vm
+      # Delete the dotfile if it exists
+      File.delete(dotfile_path) if File.exist?(dotfile_path)
+
+      # Remove from the global store
+      active_list.remove(vm)
+    end
+
+    #---------------------------------------------------------------
+    # Methods to check for properties and error
+    #---------------------------------------------------------------
+
+    def require_root_path
+      error_and_exit(:rootfile_not_found) if !root_path
+    end
+
+    def require_box
+      require_root_path
+
+      if !box
+        if !Vagrant.config.vm.box
+          error_and_exit(:box_not_specified)
+        else
+          error_and_exit(:box_specified_doesnt_exist, :box_name => Vagrant.config.vm.box)
+        end
+      end
+    end
+
+    def require_persisted_vm
+      require_root_path
+
+      error_and_exit(:environment_not_created) if !vm
+    end
+  end
+end

data/lib/vagrant/provisioners/base.rb

@@ -7,6 +7,13 @@ module Vagrant
     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

data/lib/vagrant/provisioners/chef.rb

@@ -11,20 +11,26 @@ module Vagrant
         attr_accessor :validation_key_path
         attr_accessor :validation_client_name
         attr_accessor :client_key_path
+        attr_accessor :node_name
 
         # Chef solo specific config
         attr_accessor :cookbooks_path
+        attr_accessor :roles_path
 
         # Shared config
         attr_accessor :provisioning_path
+        attr_accessor :log_level
         attr_accessor :json
 
         def initialize
           @validation_client_name = "chef-validator"
           @client_key_path = "/etc/chef/client.pem"
+          @node_name = "client"
 
           @cookbooks_path = "cookbooks"
+          @roles_path = []
           @provisioning_path = "/tmp/vagrant-chef"
+          @log_level = :info
           @json = {
             :instance_role => "vagrant",
             :run_list => ["recipe[vagrant_main]"]
@@ -66,24 +72,33 @@ module Vagrant
       Config.configures :chef, ChefConfig
 
       def prepare
-        raise Actions::ActionException.new("Vagrant::Provisioners::Chef is not a valid provisioner! Use ChefSolo or ChefServer instead.")
+        raise Actions::ActionException.new(:chef_base_invalid_provisioner)
       end
 
       def chown_provisioning_folder
         logger.info "Setting permissions on chef provisioning folder..."
-        SSH.execute do |ssh|
-          ssh.exec!("sudo mkdir -p #{Vagrant.config.chef.provisioning_path}")
-          ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
+        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_config(template, filename, template_vars)
+        config_file = TemplateRenderer.render(template, {
+          :log_level => env.config.chef.log_level.to_sym
+        }.merge(template_vars))
+
+        logger.info "Uploading chef configuration script..."
+        env.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
+      end
+
       def setup_json
         logger.info "Generating chef JSON and uploading..."
 
         # Set up initial configuration
         data = {
-          :config => Vagrant.config,
-          :directory => Vagrant.config.vm.project_directory,
+          :config => env.config,
+          :directory => env.config.vm.project_directory,
         }
 
         # And wrap it under the "vagrant" namespace
@@ -91,12 +106,12 @@ module Vagrant
 
         # Merge with the "extra data" which isn't put under the
         # vagrant namespace by default
-        data.merge!(Vagrant.config.chef.json)
+        data.merge!(env.config.chef.json)
 
         json = data.to_json
 
-        SSH.upload!(StringIO.new(json), File.join(Vagrant.config.chef.provisioning_path, "dna.json"))
+        env.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
       end
     end
   end
-end
+end

data/lib/vagrant/provisioners/chef_server.rb

@@ -4,26 +4,14 @@ module Vagrant
     # with a chef server.
     class ChefServer < Chef
       def prepare
-        if Vagrant.config.chef.validation_key_path.nil?
-          raise Actions::ActionException.new(<<-msg)
-Chef server provisioning requires that the `config.chef.validation_key_path` configuration
-be set to a path on your local machine of the validation key used to register the
-VM with the chef server.
-msg
-        elsif !File.file?(Vagrant.config.chef.validation_key_path)
-          raise Actions::ActionException.new(<<-msg)
-The validation key set for `config.chef.validation_key_path` does not exist! This
-file needs to exist so it can be uploaded to the virtual machine. It is
-currently set to "#{Vagrant.config.chef.validation_key_path}"
-msg
+        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 Vagrant.config.chef.chef_server_url.nil?
-          raise Actions::ActionException.new(<<-msg)
-Chef server provisioning requires that the `config.chef.chef_server_url` be set to the
-URL of your chef server. Examples include "http://12.12.12.12:4000" and
-"http://myserver.com:4000" (the port of course can be different, but 4000 is the default)
-msg
+        if env.config.chef.chef_server_url.nil?
+          raise Actions::ActionException.new(:chef_server_url_required)
         end
       end
 
@@ -32,51 +20,38 @@ msg
         create_client_key_folder
         upload_validation_key
         setup_json
-        setup_config
+        setup_server_config
         run_chef_client
       end
 
       def create_client_key_folder
         logger.info "Creating folder to hold client key..."
-        path = Pathname.new(Vagrant.config.chef.client_key_path)
+        path = Pathname.new(env.config.chef.client_key_path)
 
-        SSH.execute do |ssh|
+        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..."
-        SSH.upload!(validation_key_path, guest_validation_key_path)
+        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    "#{Vagrant.config.chef.chef_server_url}"
-
-validation_client_name "#{Vagrant.config.chef.validation_client_name}"
-validation_key         "#{guest_validation_key_path}"
-client_key             "#{Vagrant.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..."
-        SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "client.rb"))
+      def setup_server_config
+        setup_config("chef_server_client", "client.rb", {
+          :node_name => env.config.chef.node_name,
+          :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
+        })
       end
 
       def run_chef_client
         logger.info "Running chef-client..."
-        SSH.execute do |ssh|
-          ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json") do |channel, data, stream|
+        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}")
@@ -85,12 +60,12 @@ solo
       end
 
       def validation_key_path
-        File.expand_path(Vagrant.config.chef.validation_key_path, Env.root_path)
+        File.expand_path(env.config.chef.validation_key_path, env.root_path)
       end
 
       def guest_validation_key_path
-        File.join(Vagrant.config.chef.provisioning_path, "validation.pem")
+        File.join(@env.config.chef.provisioning_path, "validation.pem")
       end
     end
   end
-end
+end