vagrant 0.1.0

data/lib/vagrant/actions/vm/suspend.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  module Actions
+    module VM
+      class Suspend < Base
+        def execute!
+          if !@runner.vm.running?
+            raise ActionException.new("The vagrant virtual environment you are trying to suspend must be running to be suspended.")
+          end
+
+          logger.info "Saving VM state and suspending execution..."
+          @runner.vm.save_state(true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/up.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Actions
+    module VM
+      class Up < Base
+        def prepare
+          # Up is a "meta-action" so it really just queues up a bunch
+          # of other actions in its place:
+          steps = [Import, ForwardPorts, SharedFolders, Start]
+          steps << Provision if Vagrant.config.chef.enabled
+          steps.insert(0, MoveHardDrive) if Vagrant.config.vm.hd_location
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+
+        def after_import
+          persist
+          setup_mac_address
+        end
+
+        def persist
+          logger.info "Persisting the VM UUID (#{@runner.vm.uuid})..."
+          Env.persist_vm(@runner.vm)
+        end
+
+        def setup_mac_address
+          logger.info "Matching MAC addresses..."
+          @runner.vm.nics.first.macaddress = Vagrant.config[:vm][:base_mac]
+          @runner.vm.save(true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/box.rb

@@ -0,0 +1,129 @@
+module Vagrant
+  # Represents a "box," which is simply a packaged vagrant environment.
+  # Boxes are simply `tar` files which contain an exported VirtualBox
+  # virtual machine, at the least. They are created with `vagrant package`
+  # and may contain additional files if specified by the creator. This
+  # class serves to help manage these boxes, although most of the logic
+  # is kicked out to actions.
+  #
+  # What can the {Box} class do?
+  #
+  # * Find boxes
+  # * Add existing boxes (from some URI)
+  # * Delete existing boxes
+  #
+  # # Finding Boxes
+  #
+  # Using the {Box.find} method, you can search for existing boxes. This
+  # method will return `nil` if none is found or an instance of {Box}
+  # otherwise.
+  #
+  #     box = Vagrant::Box.find("base")
+  #     if box.nil?
+  #       puts "Box not found!"
+  #     else
+  #       puts "Box exists at #{box.directory}"
+  #     end
+  #
+  # # Adding a Box
+  #
+  # Boxes can be added from any URI. Some schemas aren't supported; if this
+  # is the case, the error will output to the logger.
+  #
+  #     Vagrant::Box.add("foo", "http://myfiles.com/foo.box")
+  #
+  # # Destroying a box
+  #
+  # Boxes can be deleted as well. This method is _final_ and there is no way
+  # to undo this action once it is completed.
+  #
+  #     box = Vagrant::Box.find("foo")
+  #     box.destroy
+  #
+  class Box < Actions::Runner
+    # The name of the box.
+    attr_accessor :name
+
+    # The URI for a new box. This is not available for existing boxes.
+    attr_accessor :uri
+
+    # The temporary path to the downloaded or copied box. This should
+    # only be used internally.
+    attr_accessor :temp_path
+
+    class <<self
+      # Finds a box with the given name. This method searches for a box
+      # with the given name, returning `nil` if none is found or returning
+      # a {Box} instance otherwise.
+      #
+      # @param [String] name The name of the box
+      # @return [Box] Instance of {Box} representing the box found
+      def find(name)
+        return nil unless File.directory?(directory(name))
+        new(name)
+      end
+
+      # Adds a new box with given name from the given URI. This method
+      # begins the process of adding a box from a given URI by setting up
+      # the {Box} instance and calling {#add}.
+      #
+      # @param [String] name The name of the box
+      # @param [String] uri URI to the box file
+      def add(name, uri)
+        box = new
+        box.name = name
+        box.uri = uri
+        box.add
+      end
+
+      # Returns the directory to a box of the given name. The name given
+      # as a parameter is not checked for existence; this method simply
+      # returns the directory which would be used if the box did exist.
+      #
+      # @param [String] name Name of the box whose directory you're interested in.
+      # @return [String] Full path to the box directory.
+      def directory(name)
+        File.join(Env.boxes_path, name)
+      end
+    end
+
+    # Creates a new box instance. Given an optional `name` parameter,
+    # newly created instance will have that name, otherwise it defaults
+    # to `nil`.
+    #
+    # **Note:** This method does not actually _create_ the box, but merely
+    # returns a new, abstract representation of it. To add a box, see {#add}.
+    def initialize(name=nil)
+      @name = name
+    end
+
+    # Returns path to the OVF file of the box. The OVF file is an open
+    # virtual machine file which contains specifications of the exported
+    # virtual machine this box contains.
+    #
+    # @return [String]
+    def ovf_file
+      File.join(directory, Vagrant.config.vm.box_ovf)
+    end
+
+    # Begins the process of adding a box to the vagrant installation. This
+    # method requires that `name` and `uri` be set. The logic of this method
+    # is kicked out to the {Actions::Box::Add add box} action.
+    def add
+      execute!(Actions::Box::Add)
+    end
+
+    # Beings the process of destroying this box.
+    def destroy
+      execute!(Actions::Box::Destroy)
+    end
+
+    # Returns the directory to the location of this boxes content in the local
+    # filesystem.
+    #
+    # @return [String]
+    def directory
+      self.class.directory(self.name)
+    end
+  end
+end

data/lib/vagrant/busy.rb

@@ -0,0 +1,73 @@
+module Vagrant
+  def self.busy?
+    Busy.busy?
+  end
+
+  def self.busy(&block)
+    Busy.busy(&block)
+  end
+
+  class Busy
+    extend Vagrant::Util
+
+    @@busy = false
+    @@mutex = Mutex.new
+    @@trap_thread = nil
+
+    class << self
+      def busy?
+        @@busy
+      end
+
+      def busy=(val)
+        @@busy = val
+      end
+
+      def busy(&block)
+        @@mutex.synchronize do
+          begin
+            Signal.trap("INT") { wait_for_not_busy }
+            Busy.busy = true
+            runner = Thread.new(block) { block.call }
+            runner.join
+          ensure
+            # In the case an exception is thrown, make sure we restore
+            # busy back to some sane state.
+            Busy.busy = false
+
+            # Make sure that the trap thread completes, if it is running
+            trap_thread.join if trap_thread
+
+            # And restore the INT trap to the default
+            Signal.trap("INT", "DEFAULT")
+          end
+        end
+      end
+
+      def wait_for_not_busy(sleeptime=5)
+        @@trap_thread ||= Thread.new do
+          # Wait while the app is busy
+          loop do
+            break unless busy?
+            logger.info "Waiting for vagrant to clean itself up..."
+            sleep sleeptime
+          end
+
+          # Exit out of the entire script
+          logger.info "Exiting vagrant..."
+          exit
+        end
+      end
+
+      # Used for testing
+      def reset_trap_thread!
+        @@trap_thread = nil
+      end
+
+      # Returns the trap thread
+      def trap_thread
+        @@trap_thread
+      end
+    end
+  end
+end

data/lib/vagrant/commands.rb

@@ -0,0 +1,174 @@
+module Vagrant
+  # Contains all the command-line commands invoked by the
+  # binaries. Having them all in one location assists with
+  # documentation and also takes the commands out of some of
+  # the other classes.
+  class Commands
+    extend Vagrant::Util
+
+    class << self
+      # Initializes a directory for use with vagrant. This command copies an
+      # initial `Vagrantfile` into the current working directory so you can
+      # begin using vagrant. The configuration file contains some documentation
+      # to get you started.
+      def init
+        rootfile_path = File.join(Dir.pwd, Env::ROOTFILE_NAME)
+        if File.exist?(rootfile_path)
+          error_and_exit(<<-error)
+It looks like this directory is already setup for vagrant! (A #{Env::ROOTFILE_NAME}
+already exists.)
+error
+        end
+
+        # Copy over the rootfile template into this directory
+        File.copy(File.join(PROJECT_ROOT, "templates", Env::ROOTFILE_NAME), rootfile_path)
+      end
+
+      # 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.
+      def up
+        Env.load!
+
+        if Env.persisted_vm
+          logger.info "VM already created. Starting VM if its not already running..."
+          Env.persisted_vm.start
+        else
+          Env.require_box
+          VM.execute!(Actions::VM::Up)
+        end
+      end
+
+      # Tear down a vagrant instance. This not only shuts down the instance
+      # (if its running), but also deletes it from the system, including the
+      # hard disks associated with it.
+      #
+      # This command requires that an instance already be brought up with
+      # `vagrant up`.
+      def down
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.destroy
+      end
+
+      # 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.
+      def reload
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.execute!(Actions::VM::Reload)
+      end
+
+      # SSH into the vagrant instance. This will setup an SSH connection into
+      # the vagrant instance, replacing the running ruby process with the SSH
+      # connection.
+      #
+      # This command requires that an instance already be brought up with
+      # `vagrant up`.
+      def ssh
+        Env.load!
+        Env.require_persisted_vm
+        SSH.connect
+      end
+
+      # Halts a running vagrant instance. This forcibly halts the instance;
+      # it is the equivalent of pulling the power on a machine. The instance
+      # can be restarted again with {up}.
+      #
+      # This command requires than an instance already be brought up with
+      # `vagrant up`.
+      def halt
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.execute!(Actions::VM::Halt)
+      end
+
+      # 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`.
+      def suspend
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.suspend
+      end
+
+      # 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`.
+      def resume
+        Env.load!
+        Env.require_persisted_vm
+        Env.persisted_vm.resume
+      end
+
+      # Export and package the current vm
+      #
+      # This command requires that an instance be powered off
+      def package(out_path=nil, include_files=[])
+        Env.load!
+        Env.require_persisted_vm
+        error_and_exit(<<-error) unless Env.persisted_vm.powered_off?
+The vagrant virtual environment you are trying to package must be powered off
+error
+
+        Env.persisted_vm.package(out_path, include_files)
+      end
+
+      # Manages the `vagrant box` command, allowing the user to add
+      # and remove boxes. This single command, given an array, determines
+      # which action to take and calls the respective action method
+      # (see {box_add} and {box_remove})
+      def box(argv)
+        Env.load!(:suppress_errors => true)
+
+        sub_commands = ["add", "remove"]
+
+        if !sub_commands.include?(argv[0])
+          error_and_exit(<<-error)
+Please specify a valid action to take on the boxes, either
+`add` or `remove`. Examples:
+
+vagrant box add name uri
+vagrant box remove name
+error
+        end
+
+        send("box_#{argv[0]}", *argv[1..-1])
+      end
+
+      # Adds a box to the local filesystem, given a URI.
+      def box_add(name, path)
+        Box.add(name, path)
+      end
+
+      # Removes a box.
+      def box_remove(name)
+        box = Box.find(name)
+        if box.nil?
+          error_and_exit(<<-error)
+The box you're attempting to remove does not exist!
+error
+          return # for tests
+        end
+
+        box.destroy
+      end
+
+      private
+
+      def act_on_vm(&block)
+        yield Env.persisted_vm
+        Env.persisted_vm.execute!
+      end
+    end
+  end
+end

data/lib/vagrant/config.rb

@@ -0,0 +1,156 @@
+module Vagrant
+  def self.config
+    Config.config
+  end
+
+  class Config
+    @config = nil
+    @config_runners = []
+
+    class << self
+      def reset!
+        @config = nil
+        config_runners.clear
+      end
+
+      def config
+        @config ||= Config::Top.new
+      end
+
+      def config_runners
+        @config_runners ||= []
+      end
+
+      def run(&block)
+        config_runners << block
+      end
+
+      def execute!
+        config_runners.each do |block|
+          block.call(config)
+        end
+
+        config.loaded!
+      end
+    end
+  end
+
+  class Config
+    class Base
+      def [](key)
+        send(key)
+      end
+
+      def to_json
+        instance_variables_hash.to_json
+      end
+
+      def instance_variables_hash
+        instance_variables.inject({}) do |acc, iv|
+          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv)
+          acc
+        end
+      end
+    end
+
+    class SSHConfig < Base
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :host
+      attr_accessor :forwarded_port_key
+      attr_accessor :max_tries
+    end
+
+    class VMConfig < Base
+      attr_accessor :box
+      attr_accessor :box_ovf
+      attr_accessor :base_mac
+      attr_accessor :project_directory
+      attr_reader :forwarded_ports
+      attr_accessor :hd_location
+      attr_accessor :disk_image_format
+
+
+      def initialize
+        @forwarded_ports = {}
+      end
+
+      def forward_port(name, guestport, hostport, protocol="TCP")
+        forwarded_ports[name] = {
+          :guestport  => guestport,
+          :hostport   => hostport,
+          :protocol   => protocol
+        }
+      end
+
+      def hd_location=(val)
+        raise Exception.new "disk_storage must be set to a directory" unless File.directory?(val)
+        @hd_location=val
+      end
+
+      def base
+        File.expand_path(@base)
+      end
+    end
+
+    class PackageConfig < Base
+      attr_accessor :name
+      attr_accessor :extension
+    end
+
+    class ChefConfig < Base
+      attr_accessor :cookbooks_path
+      attr_accessor :provisioning_path
+      attr_accessor :json
+      attr_accessor :enabled
+
+      def initialize
+        @enabled = false
+      end
+
+      def to_json
+        # Overridden so that the 'json' key could be removed, since its just
+        # merged into the config anyways
+        data = instance_variables_hash
+        data.delete(:json)
+        data.to_json
+      end
+    end
+
+    class VagrantConfig < Base
+      attr_accessor :dotfile_name
+      attr_accessor :log_output
+      attr_accessor :home
+
+      def home
+        File.expand_path(@home)
+      end
+    end
+
+    class Top < Base
+      attr_reader :package
+      attr_reader :ssh
+      attr_reader :vm
+      attr_reader :chef
+      attr_reader :vagrant
+
+      def initialize
+        @ssh = SSHConfig.new
+        @vm = VMConfig.new
+        @chef = ChefConfig.new
+        @vagrant = VagrantConfig.new
+        @package = PackageConfig.new
+
+        @loaded = false
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded!
+        @loaded = true
+      end
+    end
+  end
+end