vagrantup 0.2.0 → 0.3.0

data/lib/vagrant/commands/init.rb

@@ -0,0 +1,32 @@
+module Vagrant
+  class Commands
+    class Init < Base
+      Base.subcommand "init", self
+      description "Initializes current folder for Vagrant usage"
+
+      def execute(args)
+        create_vagrantfile(args[0])
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant init [name]"
+      end
+
+      # Actually writes the initial Vagrantfile to the current working directory.
+      # The Vagrantfile will contain the base box configuration specified, or
+      # will just use "base" if none is specified.
+      #
+      # @param [String] default_box The default base box for this Vagrantfile
+      def create_vagrantfile(default_box=nil)
+        rootfile_path = File.join(Dir.pwd, Environment::ROOTFILE_NAME)
+        error_and_exit(:rootfile_already_exists) if File.exist?(rootfile_path)
+
+        # Copy over the rootfile template into this directory
+        default_box ||= "base"
+        File.open(rootfile_path, 'w+') do |f|
+          f.write(TemplateRenderer.render(Environment::ROOTFILE_NAME, :default_box => default_box))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/package.rb

@@ -0,0 +1,46 @@
+module Vagrant
+  class Commands
+    # Export and package the current vm
+    #
+    # This command requires that an instance be powered off
+    class Package < Base
+      Base.subcommand "package", self
+      description "Packages a vagrant environment for distribution"
+
+      def execute(args=[])
+        parse_options(args)
+
+        if !options[:base]
+          # Packaging a pre-existing environment
+          env.require_persisted_vm
+        else
+          # Packaging a base box; that is a VM not tied to a specific
+          # vagrant environment
+          vm = VM.find(options[:base])
+          vm.env = env if vm
+          env.vm = vm
+
+          error_and_exit(:vm_base_not_found, :name => options[:base]) unless vm
+        end
+
+        error_and_exit(:vm_power_off_to_package) unless env.vm.powered_off?
+        env.vm.package(args[0], options[:include])
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant package [--base BASE] [--include FILES]"
+
+        # Defaults
+        options[:include] = []
+
+        opts.on("--base [BASE]", "Name or UUID of VM to create a base box from") do |v|
+          options[:base] = v
+        end
+
+        opts.on("--include x,y,z", Array, "List of files to include in the package") do |v|
+          options[:include] = v
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/reload.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  class Commands
+    # Reload the environment. This is almost equivalent to the {up} command
+    # except that it doesn't import the VM and do the initialize bootstrapping
+    # of the instance. Instead, it forces a shutdown (if its running) of the
+    # VM, updates the metadata (shared folders, forwarded ports), restarts
+    # the VM, and then reruns the provisioning if enabled.
+    class Reload < Base
+      Base.subcommand "reload", self
+      description "Reload the vagrant environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.vm.execute!(Actions::VM::Reload)
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant reload"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/resume.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  class Commands
+    # Resume a running vagrant instance. This resumes an already suspended
+    # instance (from {suspend}).
+    #
+    # This command requires that an instance already be brought up with
+    # `vagrant up`.
+    class Resume < Base
+      Base.subcommand "resume", self
+      description "Resumes a suspend vagrant environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.vm.resume
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant resume"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/ssh.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  class Commands
+    # Reload the environment. This is almost equivalent to the {up} command
+    # except that it doesn't import the VM and do the initialize bootstrapping
+    # of the instance. Instead, it forces a shutdown (if its running) of the
+    # VM, updates the metadata (shared folders, forwarded ports), restarts
+    # the VM, and then reruns the provisioning if enabled.
+    class SSH < Base
+      Base.subcommand "ssh", self
+      description "SSH into the currently running environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.ssh.connect
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant ssh"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/ssh_config.rb

@@ -0,0 +1,30 @@
+module Vagrant
+  class Commands
+    # Outputs a valid entry for .ssh/config which can be used to connect
+    # to this environment.
+    class SSHConfig < Base
+      Base.subcommand "ssh-config", self
+      description "outputs .ssh/config valid syntax for connecting to this environment via ssh"
+
+      def execute(args=[])
+        env.require_root_path
+
+        parse_options(args)
+        puts TemplateRenderer.render("ssh_config", {
+          :host_key => options[:host] || "vagrant",
+          :ssh_user => env.config.ssh.username,
+          :ssh_port => env.ssh.port,
+          :private_key_path => env.config.ssh.private_key_path
+        })
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant ssh-config [--host NAME]"
+
+        opts.on("-h", "--host [HOST]", "Host name for the SSH config") do |h|
+          options[:host] = h
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/status.rb

@@ -0,0 +1,58 @@
+module Vagrant
+  class Commands
+    # Outputs the status of the current environment. This command outputs
+    # useful information such as whether or not the environment is created
+    # and if its running, suspended, etc.
+    class Status < Base
+      Base.subcommand "status", self
+      description "Shows the status of the current environment."
+
+      def execute(args=[])
+        wrap_output do
+          if !env.root_path
+            puts <<-msg
+No vagrant environment detected. Run `vagrant init` to setup a Vagrantfile
+in the current directory to get started with Vagrant.
+msg
+          elsif !env.vm
+            puts <<-msg
+The environment has not yet been created. Run `vagrant up` to create the
+environment.
+msg
+          else
+            additional_msg = ""
+            if env.vm.vm.running?
+              additional_msg = <<-msg
+To stop this VM, you can run `vagrant halt` to shut it down forcefully,
+or you can run `vagrant suspend` to simply suspend the virtual machine.
+In either case, to restart it again, simply run a `vagrant up`.
+msg
+            elsif env.vm.vm.saved?
+              additional_msg = <<-msg
+To resume this VM, simply run `vagrant up`.
+msg
+            elsif env.vm.vm.powered_off?
+              additional_msg = <<-msg
+To restart this VM, simply run `vagrant up`.
+msg
+            end
+
+            if !additional_msg.empty?
+              additional_msg.chomp!
+              additional_msg = "\n\n#{additional_msg}"
+            end
+
+            puts <<-msg
+The environment has been created. The status of the current environment's
+virtual machine is: "#{env.vm.vm.state}."#{additional_msg}
+msg
+          end
+        end
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant status"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/suspend.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  class Commands
+    # Suspend a running vagrant instance. This suspends the instance, saving
+    # the state of the VM and "pausing" it. The instance can be resumed
+    # again with {resume}.
+    #
+    # This command requires that an instance already be brought up with
+    # `vagrant up`.
+    class Suspend < Base
+      Base.subcommand "suspend", self
+      description "Suspends the currently running vagrant environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.vm.suspend
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant suspend"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/up.rb

@@ -0,0 +1,26 @@
+module Vagrant
+  class Commands
+    # Bring up a vagrant instance. This handles everything from importing
+    # the base VM, setting up shared folders, forwarded ports, etc to
+    # provisioning the instance with chef. {up} also starts the instance,
+    # running it in the background.
+    class Up < Base
+      Base.subcommand "up", self
+      description "Creates the vagrant environment"
+
+      def execute(args=[])
+        if env.vm
+          logger.info "VM already created. Starting VM if its not already running..."
+          env.vm.start
+        else
+          env.require_box
+          env.create_vm.execute!(Actions::VM::Up)
+        end
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant up"
+      end
+    end
+  end
+end

data/lib/vagrant/config.rb

@@ -4,22 +4,25 @@ module Vagrant
   end
 
   class Config
-    extend StackedProcRunner
+    extend Util::StackedProcRunner
 
     @@config = nil
 
     class << self
-      def reset!
+      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
-        @@config ||= Config::Top.new
+      def config(env=nil)
+        @@config ||= Config::Top.new(env)
       end
 
       def run(&block)
@@ -29,12 +32,15 @@ module Vagrant
       def execute!
         run_procs!(config)
         config.loaded!
+        config
       end
     end
   end
 
   class Config
     class Base
+      attr_accessor :env
+
       def [](key)
         send(key)
       end
@@ -45,7 +51,7 @@ module Vagrant
 
       def instance_variables_hash
         instance_variables.inject({}) do |acc, iv|
-          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv)
+          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv) unless iv.to_sym == :@env
           acc
         end
       end
@@ -61,16 +67,17 @@ module Vagrant
       attr_accessor :private_key_path
 
       def private_key_path
-        File.expand_path(@private_key_path, Env.root_path)
+        File.expand_path(@private_key_path, env.root_path)
       end
     end
 
     class VMConfig < Base
-      include StackedProcRunner
+      include Util::StackedProcRunner
 
       attr_accessor :box
       attr_accessor :box_ovf
       attr_accessor :base_mac
+      attr_accessor :boot_mode
       attr_accessor :project_directory
       attr_reader :forwarded_ports
       attr_reader :shared_folders
@@ -107,11 +114,11 @@ module Vagrant
       end
 
       def shared_folder_uid
-        @shared_folder_uid || Vagrant.config.ssh.username
+        @shared_folder_uid || env.config.ssh.username
       end
 
       def shared_folder_gid
-        @shared_folder_gid || Vagrant.config.ssh.username
+        @shared_folder_gid || env.config.ssh.username
       end
 
       def customize(&block)
@@ -154,12 +161,15 @@ module Vagrant
       configures :vm, VMConfig
       configures :vagrant, VagrantConfig
 
-      def initialize
+      def initialize(env=nil)
         self.class.configures_list.each do |key, klass|
-          instance_variable_set("@#{key}".to_sym, klass.new)
+          config = klass.new
+          config.env = env
+          instance_variable_set("@#{key}".to_sym, config)
         end
 
         @loaded = false
+        @env = env
       end
 
       def loaded?

data/lib/vagrant/downloaders/file.rb

@@ -3,13 +3,13 @@ module Vagrant
     # "Downloads" a file to a temporary file. Basically, this downloader
     # simply does a file copy.
     class File < Base
+      def self.match?(uri)
+        ::File.exists?(uri)
+      end
+
       def prepare(source_url)
         if !::File.file?(source_url)
-          raise Actions::ActionException.new(<<-msg)
-The given box does not exist on the file system:
-
-#{source_url}
-msg
+          raise Actions::ActionException.new(:downloader_file_doesnt_exist, :source_url => source_url)
         end
       end
 

data/lib/vagrant/downloaders/http.rb

@@ -3,8 +3,14 @@ module Vagrant
     # 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"
+      include Util::ProgressMeter
+
+      def self.match?(uri)
+        # URI.parse barfs on '<drive letter>:\\files \on\ windows'
+        # TODO temprorary
+        extracted = URI.extract(uri).first
+        extracted && extracted.include?(uri)
+      end
 
       def download!(source_url, destination_file)
         Net::HTTP.get_response(URI.parse(source_url)) do |response|
@@ -20,7 +26,7 @@ module Vagrant
             # Progress reporting is limited to every 25 segments just so
             # we're not constantly updating
             if segment_count % 25 == 0
-              report_progress(progress, total)
+              update_progress(progress, total)
               segment_count = 0
             end
 
@@ -31,17 +37,6 @@ module Vagrant
 
         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
+end