rvagrant 0.8.7.dev

data/lib/vagrant/util/platform.rb

@@ -0,0 +1,57 @@
+require 'rbconfig'
+
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def tiger?
+          platform.include?("darwin8")
+        end
+
+        def leopard?
+          platform.include?("darwin9")
+        end
+
+        [:darwin, :bsd, :linux].each do |type|
+          define_method("#{type}?") do
+            platform.include?(type.to_s)
+          end
+        end
+
+        def windows?
+          %W[mingw mswin].each do |text|
+            return true if platform.include?(text)
+          end
+
+          false
+        end
+
+        # Returns boolean noting whether this is a 64-bit CPU. This
+        # is not 100% accurate and there could easily be false negatives.
+        #
+        # @return [Boolean]
+        def bit64?
+          ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
+        end
+
+        # Returns boolean noting whether this is a 32-bit CPU. This
+        # can easily throw false positives since it relies on {#bit64?}.
+        #
+        # @return [Boolean]
+        def bit32?
+          !bit64?
+        end
+
+        def tar_file_options
+          # create, write only, fail if the file exists, binary if windows
+          File::WRONLY | File::EXCL | File::CREAT | (windows? ? File::BINARY : 0)
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,25 @@
+module Vagrant
+  module Util
+    module Retryable
+      # Retries a given block a specified number of times in the
+      # event the specified exception is raised. If the retries
+      # run out, the final exception is raised.
+      #
+      # This code is adapted slightly from the following blog post:
+      # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+      def retryable(opts=nil)
+        opts = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on]
+          if (opts[:tries] -= 1) > 0
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_exec.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # This module provies a `safe_exec` method which is a drop-in
+    # replacement for `Kernel.exec` which addresses a specific issue
+    # which manifests on OS X 10.5 and perhaps other operating systems.
+    # This issue causes `exec` to fail if there is more than one system
+    # thread. In that case, `safe_exec` automatically falls back to
+    # forking.
+    module SafeExec
+      def safe_exec(command)
+        # Create a list of things to rescue from. Since this is OS
+        # specific, we need to do some defined? checks here to make
+        # sure they exist.
+        rescue_from = []
+        rescue_from << Errno::EOPNOTSUPP if defined?(Errno::EOPNOTSUPP)
+        rescue_from << Errno::E045 if defined?(Errno::E045)
+
+        fork_instead = false
+        begin
+          pid = nil
+          pid = fork if fork_instead
+          Kernel.exec(command) if pid.nil?
+          Process.wait(pid) if pid
+        rescue *rescue_from
+          # We retried already, raise the issue and be done
+          raise if fork_instead
+
+          # The error manifested itself, retry with a fork.
+          fork_instead = true
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/stacked_proc_runner.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # Represents the "stacked proc runner" behavior which is used a
+    # couple places within Vagrant. This allows procs to "stack" on
+    # each other, then all execute in a single action. An example of
+    # its uses can be seen in the {Config} class.
+    module StackedProcRunner
+      # Returns the proc stack. This should always be called as the
+      # accessor of the stack. The instance variable itself should _never_
+      # be used.
+      #
+      # @return [Array<Proc>]
+      def proc_stack
+        @_proc_stack ||= []
+      end
+
+      # Adds (pushes) a proc to the stack. The actual proc added here is
+      # not executed, but merely stored.
+      #
+      # @param [Proc] block
+      def push_proc(&block)
+        proc_stack << block
+      end
+
+      # Executes all the procs on the stack, passing in the given arguments.
+      # The stack is not cleared afterwords. It is up to the user of this
+      # mixin to clear the stack by calling `proc_stack.clear`.
+      def run_procs!(*args)
+        proc_stack.each do |proc|
+          proc.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+require 'erubis'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class << self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      def initialize(template, data = {})
+        super()
+
+        data[:template] = template
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Renders the template using the class intance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        Erubis::Eruby.new(template, :trim => true).result(binding)
+      end
+
+      # Returns the full path to the template, taking into accoun the gem directory
+      # and adding the `.erb` extension to the end.
+      #
+      # @return [String]
+      def full_template_path
+        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
+      end
+    end
+  end
+end

data/lib/vagrant/version.rb

@@ -0,0 +1,6 @@
+module Vagrant
+  # This will always be up to date with the current version of Vagrant,
+  # since it is used to generate the gemspec and is also the source of
+  # the version for `vagrant -v`
+  VERSION = "0.8.7.dev"
+end

data/lib/vagrant/vm.rb

@@ -0,0 +1,181 @@
+module Vagrant
+  class VM
+    include Vagrant::Util
+
+    attr_reader :env
+    attr_reader :name
+    attr_reader :vm
+
+    class << self
+      # Finds a virtual machine by a given UUID and either returns
+      # a Vagrant::VM object or returns nil.
+      def find(uuid, env=nil, name=nil)
+        vm = VirtualBox::VM.find(uuid)
+        new(:vm => vm, :env => env, :name => name)
+      end
+    end
+
+    def initialize(opts=nil)
+      defaults = {
+        :vm => nil,
+        :env => nil,
+        :name => nil
+      }
+
+      opts = defaults.merge(opts || {})
+
+      @vm = opts[:vm]
+      @name = opts[:name]
+
+      if !opts[:env].nil?
+        # We have an environment, so we create a new child environment
+        # specifically for this VM. This step will load any custom
+        # config and such.
+        @env = Vagrant::Environment.new({
+          :cwd => opts[:env].cwd,
+          :parent => opts[:env],
+          :vm => self
+        }).load!
+
+        # Load the associated system.
+        load_system!
+      end
+
+      @loaded_system_distro = false
+    end
+
+    # Loads the system associated with the VM. The system class is
+    # responsible for OS-specific functionality. More information
+    # can be found by reading the documentation on {Vagrant::Systems::Base}.
+    #
+    # **This method should never be called manually.**
+    def load_system!(system=nil)
+      system ||= env.config.vm.system
+      env.logger.info("vm: #{name}") { "Loading system: #{system}" }
+
+      if system.is_a?(Class)
+        raise Errors::VMSystemError, :_key => :invalid_class, :system => system.to_s if !(system <= Systems::Base)
+        @system = system.new(self)
+      elsif system.is_a?(Symbol)
+        # Hard-coded internal systems
+        mapping = {
+          :debian  => Systems::Debian,
+          :ubuntu  => Systems::Ubuntu,
+          :freebsd => Systems::FreeBSD,
+          :gentoo  => Systems::Gentoo,
+          :redhat  => Systems::Redhat,
+          :suse    => Systems::Suse,
+          :linux   => Systems::Linux,
+          :solaris => Systems::Solaris,
+          :arch    => Systems::Arch
+        }
+
+        raise Errors::VMSystemError, :_key => :unknown_type, :system => system.to_s if !mapping.has_key?(system)
+        @system = mapping[system].new(self)
+      else
+        raise Errors::VMSystemError, :unspecified
+      end
+    end
+
+    # Returns the system for this VM, loading the distro of the system if
+    # we can.
+    def system
+      if !@loaded_system_distro && created? && vm.running?
+        # Load the system distro for the first time
+        result = @system.distro_dispatch
+        load_system!(result)
+        @loaded_system_distro = true
+      end
+
+      @system
+    end
+
+    # Access the {Vagrant::SSH} object associated with this VM.
+    # On the initial call, this will initialize the object. On
+    # subsequent calls it will reuse the existing object.
+    def ssh
+      @ssh ||= SSH.new(env)
+    end
+
+    # Returns a boolean true if the VM has been created, otherwise
+    # returns false.
+    #
+    # @return [Boolean]
+    def created?
+      !vm.nil?
+    end
+
+    # Sets the currently active VM for this VM. If the VM is a valid,
+    # created virtual machine, then it will also update the local data
+    # to persist the VM. Otherwise, it will remove itself from the
+    # local data (if it exists).
+    def vm=(value)
+      @vm = value
+      env.local_data[:active] ||= {}
+
+      if value && value.uuid
+        env.local_data[:active][name.to_s] = value.uuid
+      else
+        env.local_data[:active].delete(name.to_s)
+      end
+
+      # Commit the local data so that the next time vagrant is initialized,
+      # it realizes the VM exists
+      env.local_data.commit
+    end
+
+    def uuid
+      vm ? vm.uuid : nil
+    end
+
+    def reload!
+      @vm = VirtualBox::VM.find(@vm.uuid)
+    end
+
+    def package(options=nil)
+      env.actions.run(:package, { "validate" => false }.merge(options || {}))
+    end
+
+    def up(options=nil)
+      env.actions.run(:up, options)
+    end
+
+    def start(options=nil)
+      raise Errors::VMInaccessible if !@vm.accessible?
+      return if @vm.running?
+      return resume if @vm.saved?
+
+      env.actions.run(:start, options)
+    end
+
+    def halt(options=nil)
+      env.actions.run(:halt, options)
+    end
+
+    def reload
+      env.actions.run(:reload)
+    end
+
+    def provision
+      env.actions.run(:provision)
+    end
+
+    def destroy
+      env.actions.run(:destroy)
+    end
+
+    def suspend
+      env.actions.run(:suspend)
+    end
+
+    def resume
+      env.actions.run(:resume)
+    end
+
+    def saved?
+      @vm.saved?
+    end
+
+    def powered_off?; @vm.powered_off? end
+  end
+end

data/templates/chef_server_client.erb

@@ -0,0 +1,32 @@
+log_level          <%= log_level.inspect %>
+log_location       STDOUT
+<% if node_name %>
+node_name          "<%= node_name %>"
+<% end %>
+ssl_verify_mode    :verify_none
+chef_server_url    "<%= chef_server_url %>"
+
+validation_client_name "<%= validation_client_name %>"
+validation_key         "<%= validation_key %>"
+client_key             "<%= client_key %>"
+
+encrypted_data_bag_secret "<%= encrypted_data_bag_secret %>"
+
+<% unless environment.nil? %>
+environment        "<%= environment %>"
+<% end %>
+
+file_cache_path    "<%= file_cache_path %>"
+file_backup_path   "<%= file_backup_path %>"
+
+http_proxy <%= http_proxy.inspect %>
+http_proxy_user <%= http_proxy_user.inspect %>
+http_proxy_pass <%= http_proxy_pass.inspect %>
+https_proxy <%= https_proxy.inspect %>
+https_proxy_user <%= https_proxy_user.inspect %>
+https_proxy_pass <%= https_proxy_pass.inspect %>
+no_proxy <%= no_proxy.inspect %>
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true