bmabey-vagrant 0.2.0

data/lib/vagrant/config.rb

@@ -0,0 +1,183 @@
+module Vagrant
+  def self.config
+    Config.config
+  end
+
+  class Config
+    extend Util::StackedProcRunner
+
+    @@config = nil
+
+    class << self
+      def reset!(env=nil)
+        @@config = nil
+        proc_stack.clear
+
+        # Reset the configuration to the specified environment
+        config(env)
+      end
+
+      def configures(key, klass)
+        config.class.configures(key, klass)
+      end
+
+      def config(env=nil)
+        @@config ||= Config::Top.new(env)
+      end
+
+      def run(&block)
+        push_proc(&block)
+      end
+
+      def execute!
+        run_procs!(config)
+        config.loaded!
+        config
+      end
+    end
+  end
+
+  class Config
+    class Base
+      attr_accessor :env
+
+      def [](key)
+        send(key)
+      end
+
+      def to_json
+        instance_variables_hash.to_json
+      end
+
+      def instance_variables_hash
+        instance_variables.inject({}) do |acc, iv|
+          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv)
+          acc
+        end
+      end
+    end
+
+    class SSHConfig < Base
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :host
+      attr_accessor :forwarded_port_key
+      attr_accessor :max_tries
+      attr_accessor :timeout
+      attr_accessor :private_key_path
+
+      def private_key_path
+        File.expand_path(@private_key_path, env.root_path)
+      end
+    end
+
+    class VMConfig < Base
+      include Util::StackedProcRunner
+
+      attr_accessor :box
+      attr_accessor :box_ovf
+      attr_accessor :base_mac
+      attr_accessor :project_directory
+      attr_reader :forwarded_ports
+      attr_reader :shared_folders
+      attr_accessor :hd_location
+      attr_accessor :disk_image_format
+      attr_accessor :provisioner
+      attr_accessor :shared_folder_uid
+      attr_accessor :shared_folder_gid
+
+      def initialize
+        @forwarded_ports = {}
+        @shared_folders = {}
+        @provisioner = nil
+      end
+
+      def forward_port(name, guestport, hostport, protocol="TCP")
+        forwarded_ports[name] = {
+          :guestport  => guestport,
+          :hostport   => hostport,
+          :protocol   => protocol
+        }
+      end
+
+      def share_folder(name, guestpath, hostpath)
+        @shared_folders[name] = {
+          :guestpath => guestpath,
+          :hostpath => hostpath
+        }
+      end
+
+      def hd_location=(val)
+        raise Exception.new("disk_storage must be set to a directory") unless File.directory?(val)
+        @hd_location=val
+      end
+
+      def shared_folder_uid
+        @shared_folder_uid || env.config.ssh.username
+      end
+
+      def shared_folder_gid
+        @shared_folder_gid || env.config.ssh.username
+      end
+
+      def customize(&block)
+        push_proc(&block)
+      end
+    end
+
+    class PackageConfig < Base
+      attr_accessor :name
+      attr_accessor :extension
+    end
+
+    class VagrantConfig < Base
+      attr_accessor :dotfile_name
+      attr_accessor :log_output
+      attr_accessor :home
+
+      def home
+        @home ? File.expand_path(@home) : nil
+      end
+    end
+
+    class Top < Base
+      @@configures = []
+
+      class <<self
+        def configures_list
+          @@configures ||= []
+        end
+
+        def configures(key, klass)
+          configures_list << [key, klass]
+          attr_reader key.to_sym
+        end
+      end
+
+      # Setup default configures
+      configures :package, PackageConfig
+      configures :ssh, SSHConfig
+      configures :vm, VMConfig
+      configures :vagrant, VagrantConfig
+
+      def initialize(env=nil)
+        self.class.configures_list.each do |key, klass|
+          config = klass.new
+          config.env = env
+          instance_variable_set("@#{key}".to_sym, config)
+        end
+
+        @loaded = false
+        @env = env
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded!
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders/base.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  module Downloaders
+    # Represents a base class for a downloader. A downloader handles
+    # downloading a box file to a temporary file.
+    class Base
+      include Vagrant::Util
+
+      # Called prior to execution so any error checks can be done
+      def prepare(source_url); end
+
+      # Downloads the source file to the destination file. It is up to
+      # implementors of this class to handle the logic.
+      def download!(source_url, destination_file); end
+    end
+  end
+end

data/lib/vagrant/downloaders/file.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Downloaders
+    # "Downloads" a file to a temporary file. Basically, this downloader
+    # simply does a file copy.
+    class File < Base
+      def prepare(source_url)
+        if !::File.file?(source_url)
+          raise Actions::ActionException.new(:downloader_file_doesnt_exist, :source_url => source_url)
+        end
+      end
+
+      def download!(source_url, destination_file)
+        FileUtils.cp(source_url, destination_file.path)
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders/http.rb

@@ -0,0 +1,47 @@
+module Vagrant
+  module Downloaders
+    # Downloads a file from an HTTP URL to a temporary file. This
+    # downloader reports its progress to stdout while downloading.
+    class HTTP < Base
+      # ANSI escape code to clear lines from cursor to end of line
+      CL_RESET = "\r\e[0K"
+
+      def download!(source_url, destination_file)
+        Net::HTTP.get_response(URI.parse(source_url)) do |response|
+          total = response.content_length
+          progress = 0
+          segment_count = 0
+
+          response.read_body do |segment|
+            # Report the progress out
+            progress += segment.length
+            segment_count += 1
+
+            # Progress reporting is limited to every 25 segments just so
+            # we're not constantly updating
+            if segment_count % 25 == 0
+              report_progress(progress, total)
+              segment_count = 0
+            end
+
+            # Store the segment
+            destination_file.write(segment)
+          end
+        end
+
+        complete_progress
+      end
+
+      def report_progress(progress, total)
+        percent = (progress.to_f / total.to_f) * 100
+        print "#{CL_RESET}Download Progress: #{percent.to_i}% (#{progress} / #{total})"
+        $stdout.flush
+      end
+
+      def complete_progress
+        # Just clear the line back out
+        print "#{CL_RESET}"
+      end
+    end
+  end
+end

data/lib/vagrant/environment.rb

@@ -0,0 +1,263 @@
+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_reader :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::Command.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
+
+        if !VirtualBox::Global.vboxconfig?
+          error_and_exit(:virtualbox_xml_not_detected)
+        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 {Commands} 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 = Commands.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