fixed-vagrant 0.7.4.dev

data/lib/vagrant/util/resource_logger.rb

@@ -0,0 +1,63 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # Represents a logger for a specific resource within Vagrant. Each
+    # logger should be initialized and set to represent a single
+    # resource. Each logged message will then appear in the following
+    # format:
+    #
+    #     [resource] message
+    #
+    # This class is thread safe. The backing class which actually does
+    # all the logging IO is protected.
+    class ResourceLogger
+      @@singleton_logger = nil
+      @@writer_lock = Mutex.new
+
+      # The resource which this logger represents.
+      attr_reader :resource
+
+      # The environment that this logger is part of
+      attr_reader :env
+
+      # The backing logger which actually handles the IO. This logger
+      # should be a subclass of the standard library Logger, in general.
+      # IMPORTANT: This logger must be thread-safe.
+      attr_reader :logger
+
+      class << self
+        # Returns a singleton logger. If one has not yet be
+        # instantiated, then the given environment will be used to
+        # create a new logger.
+        def singleton_logger(env=nil)
+          return PlainLogger.new(nil) if !env.loaded?
+
+          @@singleton_logger ||= begin
+            file = env.log_path.join("#{Time.now.to_i}.log")
+            PlainLogger.new(file)
+          end
+        end
+
+        # Resets the singleton logger (only used for testing).
+        def reset_singleton_logger!
+          @@singleton_logger = nil
+        end
+      end
+
+      def initialize(resource, env)
+        @resource = resource
+        @env = env
+        @logger = self.class.singleton_logger(env)
+      end
+
+      [:debug, :info, :error, :fatal].each do |method|
+        define_method(method) do |message|
+          @@writer_lock.synchronize do
+            logger.send(method, "[#{resource}] #{message}")
+          end
+        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/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.7.4.dev"
+end

data/lib/vagrant/vm.rb

@@ -0,0 +1,177 @@
+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
+
+      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,
+          :linux   => Systems::Linux,
+          :solaris => Systems::Solaris
+        }
+
+        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)
+      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,18 @@
+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 %>"
+
+file_cache_path    "<%= file_cache_path %>"
+file_backup_path   "<%= file_backup_path %>"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true

data/templates/chef_solo_solo.erb

@@ -0,0 +1,19 @@
+<% if node_name %>
+node_name "<%= node_name %>"
+<% end %>
+file_cache_path "<%= provisioning_path %>"
+cookbook_path <%= cookbooks_path %>
+role_path <%= roles_path %>
+log_level <%= log_level.inspect %>
+
+<% if recipe_url -%>
+recipe_url "<%= recipe_url %>"
+<% end -%>
+
+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 %>

data/templates/commands/init/Vagrantfile.erb

@@ -0,0 +1,82 @@
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "<%= box_name %>"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  <% if box_url.nil? %># <% end %>config.vm.box_url = "<%= box_url || "http://domain.com/path/to/above.box" %>"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host only network IP, allowing you to access it
+  # via the IP.
+  # config.vm.network "33.33.33.10"
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port "http", 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file <%= box_name %>.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "<%= box_name %>.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path (relative
+  # to this Vagrantfile), and adding some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "cookbooks"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json.merge!({ :mysql_password => "foo" })
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_server do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end