vagrant-fixed-ssh 1.0.7

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 = "1.0.7"
+end

data/lib/vagrant/vm.rb

@@ -0,0 +1,195 @@
+require 'log4r'
+
+module Vagrant
+  class VM
+    include Vagrant::Util
+
+    attr_reader :uuid
+    attr_reader :env
+    attr_reader :name
+    attr_reader :vm
+    attr_reader :box
+    attr_reader :config
+    attr_reader :driver
+
+    def initialize(name, env, config, opts=nil)
+      @logger = Log4r::Logger.new("vagrant::vm")
+
+      @name   = name
+      @vm     = nil
+      @env    = env
+      @config = config
+      @box    = env.boxes.find(config.vm.box)
+
+      opts ||= {}
+      if opts[:base]
+        # The name is the ID we use.
+        @uuid = name
+      else
+        # Load the UUID if its saved.
+        active = env.local_data[:active] || {}
+        @uuid = active[@name.to_s]
+      end
+
+      # Reload ourselves to get the state
+      reload!
+
+      # Load the associated guest.
+      load_guest!
+      @loaded_guest_distro = false
+    end
+
+    # Loads the guest associated with the VM. The guest class is
+    # responsible for OS-specific functionality. More information
+    # can be found by reading the documentation on {Vagrant::Guest::Base}.
+    #
+    # **This method should never be called manually.**
+    def load_guest!(guest=nil)
+      guest ||= config.vm.guest
+      @logger.info("Loading guest: #{guest}")
+
+      if guest.is_a?(Class)
+        raise Errors::VMGuestError, :_key => :invalid_class, :guest => guest.to_s if !(guest <= Guest::Base)
+        @guest = guest.new(self)
+      elsif guest.is_a?(Symbol)
+        guest_klass = Vagrant.guests.get(guest)
+        raise Errors::VMGuestError, :_key => :unknown_type, :guest => guest.to_s if !guest_klass
+        @guest = guest_klass.new(self)
+      else
+        raise Errors::VMGuestError, :unspecified
+      end
+    end
+
+    # Returns a channel object to communicate with the virtual
+    # machine.
+    def channel
+      @channel ||= Communication::SSH.new(self)
+    end
+
+    # Returns the guest for this VM, loading the distro of the system if
+    # we can.
+    def guest
+      if !@loaded_guest_distro && state == :running
+        # Load the guest distro for the first time
+        result = @guest.distro_dispatch
+        load_guest!(result)
+        @loaded_guest_distro = true
+      end
+
+      @guest
+    end
+
+    # Access the {Vagrant::SSH} object associated with this VM, which
+    # is used to get SSH credentials with the virtual machine.
+    def ssh
+      @ssh ||= SSH.new(self)
+    end
+
+    # Returns the state of the VM as a symbol.
+    #
+    # @return [Symbol]
+    def state
+      return :not_created if !@uuid
+      state = @driver.read_state
+      return :not_created if !state
+      return state
+    end
+
+    # Returns a boolean true if the VM has been created, otherwise
+    # returns false.
+    #
+    # @return [Boolean]
+    def created?
+      state != :not_created
+    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 uuid=(value)
+      env.local_data[:active] ||= {}
+      if value
+        env.local_data[:active][name.to_s] = value
+      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
+
+      # Store the uuid and reload the instance
+      @uuid = value
+      reload!
+    end
+
+    def reload!
+      begin
+        @driver = Driver::VirtualBox.new(@uuid)
+      rescue Driver::VirtualBox::VMNotFound
+        # Clear the UUID since this VM doesn't exist.
+        @uuid = nil
+
+        # Reset the driver. This shouldn't raise a VMNotFound since we won't
+        # feed it a UUID.
+        @driver = Driver::VirtualBox.new
+      end
+    end
+
+    def package(options=nil)
+      run_action(:package, { "validate" => false }.merge(options || {}))
+    end
+
+    def up(options=nil)
+      run_action(:up, options)
+    end
+
+    def start(options=nil)
+      return if state == :running
+      return resume if state == :saved
+
+      run_action(:start, options)
+    end
+
+    def halt(options=nil)
+      run_action(:halt, options)
+    end
+
+    def reload(options=nil)
+      run_action(:reload, options)
+    end
+
+    def provision
+      run_action(:provision)
+    end
+
+    def destroy
+      run_action(:destroy)
+    end
+
+    def suspend
+      run_action(:suspend)
+    end
+
+    def resume
+      run_action(:resume)
+    end
+
+    def ui
+      return @_ui if defined?(@_ui)
+      @_ui = @env.ui.dup
+      @_ui.resource = @name
+      @_ui
+    end
+
+    def run_action(name, options=nil)
+      options = {
+        :vm => self,
+        :ui => ui
+      }.merge(options || {})
+
+      env.action_runner.run(name, options)
+    end
+  end
+end

data/tasks/acceptance.rake

@@ -0,0 +1,113 @@
+require 'digest/sha1'
+require 'net/http'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+require 'childprocess'
+
+require 'vagrant/util/file_checksum'
+
+namespace :acceptance do
+  desc "Downloads the boxes required for running the acceptance tests."
+  task :boxes, :directory do |t, args|
+    # Create the directory where the boxes will be downloaded
+    box_dir = Pathname.new(args[:directory] || File.expand_path("../../boxes", __FILE__))
+    box_dir.mkpath
+    puts "Boxes will be placed in: #{box_dir}"
+
+    # Load the required boxes
+    boxes = YAML.load_file(File.expand_path("../../test/config/acceptance_boxes.yml", __FILE__))
+
+    boxes.each do |box|
+      puts "Box: #{box["name"]}"
+      box_file = box_dir.join("#{box["name"]}.box")
+      checksum = FileChecksum.new(box_file, Digest::SHA1)
+
+      # If the box exists, we need to check the checksum and determine if we need
+      # to redownload the file.
+      if box_file.exist?
+        print "Box exists, checking SHA1 sum... "
+        if checksum.checksum == box["checksum"]
+          print "OK\n"
+          next
+        else
+          print "FAIL\n"
+        end
+      end
+
+      # Download the file. Note that this has no error checking and just uses
+      # pure net/http. There could be a better way.
+      puts "Downloading: #{box["url"]}"
+      destination = box_file.open("wb")
+      uri = URI.parse(box["url"])
+      Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.request_get(uri.request_uri) do |response|
+          total = response.content_length
+          progress = 0
+          count = 0
+
+          response.read_body do |segment|
+            # Really elementary progress meter
+            progress += segment.length
+            count += 1
+            puts "Progress: #{(progress.to_f / total.to_f) * 100}%" if count % 300 == 0
+
+            # Write out to the destination file
+            destination.write(segment)
+          end
+        end
+      end
+
+      destination.close
+
+      # Check the checksum of the new file to verify that it
+      # downloaded properly. This shouldn't happen, but it can!
+      if checksum.checksum != box["checksum"]
+        puts "Checksum didn't match! Download was corrupt!"
+        abort
+      end
+    end
+  end
+
+  desc "Generates the configuration for acceptance tests from current source."
+  task :config, :box_dir do |t, args|
+    require File.expand_path("../../lib/vagrant/version", __FILE__)
+    require File.expand_path('../../test/support/tempdir', __FILE__)
+
+    # Get the directory for the boxes
+    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../boxes", __FILE__))
+
+    # Generate the binstubs for the Vagrant binary
+    tempdir = Tempdir.new
+    process = ChildProcess.build("bundle", "install", "--binstubs", tempdir.path)
+    process.io.inherit!
+    process.start
+    process.poll_for_exit(64000)
+    if process.exit_code != 0
+      # Bundle install failed...
+      puts "Bundle install failed!"
+      abort
+    end
+
+    # Generate the actual configuration
+    config = {
+      "vagrant_path" => File.join(tempdir.path, "vagrant"),
+      "vagrant_version" => Vagrant::VERSION,
+      "env" => {
+        "BUNDLE_GEMFILE" => File.expand_path("../../Gemfile", __FILE__)
+      },
+      "box_directory" => box_dir.to_s
+    }
+
+    File.open("acceptance_config.yml", "w+") do |f|
+      f.write(YAML.dump(config))
+    end
+
+    puts <<-OUTPUT
+Acceptance test configuration is now in this directory in
+"acceptance_config.yml." Set your ACCEPTANCE_CONFIG environmental
+variable to this file and run any of the acceptance tests now.
+OUTPUT
+  end
+end

data/tasks/bundler.rake

@@ -0,0 +1,3 @@
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks

data/tasks/test.rake

@@ -0,0 +1,20 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+namespace :test do
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "unit"
+    t.pattern = "test/unit/**/*_test.rb"
+  end
+
+  Rake::TestTask.new do |t|
+    t.name = "unit_old"
+    t.libs << "test/unit_legacy"
+    t.pattern = "test/unit_legacy/**/*_test.rb"
+  end
+
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "acceptance"
+    t.pattern = "test/acceptance/**/*_test.rb"
+  end
+end

data/templates/commands/init/Vagrantfile.erb

@@ -0,0 +1,99 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+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. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "192.168.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # 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 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:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # 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, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :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_client 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