bmabey-vagrant 0.2.0

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

@@ -0,0 +1,18 @@
+module Vagrant
+  module Actions
+    module VM
+      class Start < Base
+        def prepare
+          # Start is a "meta-action" so it really just queues up a bunch
+          # of other actions in its place:
+          steps = [ForwardPorts, SharedFolders, Boot]
+          steps.unshift(Customize) unless @runner.vm.saved?
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+      end
+    end
+  end
+end

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(:vm_not_running_for_suspend)
+          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,40 @@
+module Vagrant
+  module Actions
+    module VM
+      class Up < Base
+        def prepare
+          # If the dotfile is not a file, raise error
+          if File.exist?(@runner.env.dotfile_path) && !File.file?(@runner.env.dotfile_path)
+            raise ActionException.new(:dotfile_error, :env => @runner.env)
+          end
+
+          # Up is a "meta-action" so it really just queues up a bunch
+          # of other actions in its place:
+          steps = [Import, Customize, ForwardPorts, SharedFolders, Boot]
+          steps << Provision if !@runner.env.config.vm.provisioner.nil?
+          steps.insert(0, MoveHardDrive) if @runner.env.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.uuid})..."
+          @runner.env.persist_vm
+        end
+
+        def setup_mac_address
+          logger.info "Matching MAC addresses..."
+          @runner.vm.nics.first.macaddress = @runner.env.config.vm.base_mac
+          @runner.vm.save(true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/active_list.rb

@@ -0,0 +1,73 @@
+module Vagrant
+  # This class represents the active list of vagrant virtual
+  # machines.
+  class ActiveList
+    FILENAME = "active.json"
+
+    @@list = nil
+
+    # The environment this active list belongs to
+    attr_accessor :env
+
+    # Creates the instance of the ActiveList, with the given environment
+    # if specified
+    def initialize(env=nil)
+      @env = env
+    end
+
+    # Parses and returns the list of UUIDs from the active VM
+    # JSON file. This will cache the result, which can be reloaded
+    # by setting the `reload` parameter to true.
+    #
+    # @return [Array<String>]
+    def list(reload=false)
+      return @list unless @list.nil? || reload
+
+      @list ||= []
+      return @list unless File.file?(path)
+      File.open(path, "r") do |f|
+        @list = JSON.parse(f.read)
+      end
+
+      @list
+    end
+
+    # Returns an array of {Vagrant::VM} objects which are currently
+    # active.
+    def vms
+      list.collect { |uuid| Vagrant::VM.find(uuid) }.compact
+    end
+
+    # Returns an array of UUIDs filtered so each is verified to exist.
+    def filtered_list
+      vms.collect { |vm| vm.uuid }
+    end
+
+    # Adds a virtual environment to the list of active virtual machines
+    def add(vm)
+      list << vm.uuid
+      list.uniq!
+      save
+    end
+
+    # Remove a virtual environment from the list of active virtual machines
+    def remove(vm)
+      vm = vm.uuid if vm.is_a?(Vagrant::VM)
+      list.delete(vm)
+      save
+    end
+
+    # Persists the list down to the JSON file.
+    def save
+      File.open(path, "w+") do |f|
+        f.write(filtered_list.to_json)
+      end
+    end
+
+    # Returns the path to the JSON file which holds the UUIDs of the
+    # active virtual machines managed by Vagrant.
+    def path
+      File.join(env.home_path, FILENAME)
+    end
+  end
+end

data/lib/vagrant/box.rb

@@ -0,0 +1,152 @@
+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
+
+    # The environment which this box belongs to. Although this could
+    # actually be many environments, this points to the environment
+    # of a specific instance.
+    attr_accessor :env
+
+    class <<self
+      # Returns an array of all created boxes, as strings.
+      #
+      # @return [Array<String>]
+      def all(env)
+        results = []
+
+        Dir.open(env.boxes_path) do |dir|
+          dir.each do |d|
+            next if d == "." || d == ".." || !File.directory?(File.join(env.boxes_path, d))
+            results << d.to_s
+          end
+        end
+
+        results
+      end
+
+      # 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(env, name)
+        return nil unless File.directory?(directory(env, name))
+        new(env, 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(env, name, uri)
+        box = new
+        box.name = name
+        box.uri = uri
+        box.env = env
+        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(env, 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(env=nil, name=nil)
+      @name = name
+      @env = env
+    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(env, 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,219 @@
+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
+    include Vagrant::Util
+
+    # The environment which these commands will act on
+    attr_reader :env
+
+    # Initialize a new {Commands} instance for the given environment.
+    # This merely prepares the {env} variable.
+    def initialize(env)
+      @env = env
+    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
+      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
+
+    # 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.require_persisted_vm
+      env.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.require_persisted_vm
+      env.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.require_persisted_vm
+      env.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.require_persisted_vm
+      env.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.require_persisted_vm
+      env.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.require_persisted_vm
+      env.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.require_persisted_vm
+      error_and_exit(:vm_power_off_to_package) unless env.vm.powered_off?
+
+      env.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)
+      sub_commands = ["list", "add", "remove"]
+
+      if !sub_commands.include?(argv[0])
+        error_and_exit(:command_box_invalid)
+      end
+
+      send("box_#{argv[0]}", env, *argv[1..-1])
+    end
+
+    # Lists all added boxes
+    def box_list(env)
+      boxes = Box.all(env).sort
+
+      wrap_output do
+        if !boxes.empty?
+          puts "Installed Vagrant Boxes:\n\n"
+          boxes.each do |box|
+            Kernel.puts box
+          end
+        else
+          Kernel.puts "No Vagrant Boxes Added!"
+        end
+      end
+    end
+
+    # Adds a box to the local filesystem, given a URI.
+    def box_add(env, name, path)
+      Box.add(env, name, path)
+    end
+
+    # Removes a box.
+    def box_remove(env, name)
+      box = Box.find(env, name)
+      if box.nil?
+        error_and_exit(:box_remove_doesnt_exist)
+        return # for tests
+      end
+
+      box.destroy
+    end
+
+    # 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.
+    def status
+      wrap_output do
+        if !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
+
+    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(default_box=nil)
+        rootfile_path = File.join(Dir.pwd, Environment::ROOTFILE_NAME)
+        if File.exist?(rootfile_path)
+          error_and_exit(:rootfile_already_exists)
+        end
+
+        # 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
+
+      # Runs a command in the current environment by loading the environment
+      # of the current working directory prior to executing.
+      def execute(command, *args)
+        env = Environment.load!
+        env.commands.send(command, *args)
+      end
+    end
+  end
+end