vagrant 1.0.7 → 1.5.0

data/lib/vagrant/util/template_renderer.rb

@@ -1,83 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

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

data/tasks/test.rake

@@ -1,20 +0,0 @@
-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

@@ -1,99 +0,0 @@
-# -*- 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