vagrant 0.5.4 → 0.6.0

data/lib/vagrant/commands/box/remove.rb

@@ -1,30 +0,0 @@
-module Vagrant
-  class Commands
-    # Removes a box permanently from the hard drive.
-    module Box
-      class Remove < BoxCommand
-        BoxCommand.subcommand "remove", self
-        description "Remove an installed box permanently."
-
-        def execute(args=[])
-          if args.length != 1
-            show_help
-            return
-          end
-
-          box = Vagrant::Box.find(env, args[0])
-          if box.nil?
-            error_and_exit(:box_remove_doesnt_exist)
-            return # for tests
-          end
-
-          box.destroy
-        end
-
-        def options_spec(opts)
-          opts.banner = "Usage: vagrant box remove NAME"
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/box/repackage.rb

@@ -1,35 +0,0 @@
-module Vagrant
-  class Commands
-    module Box
-      # Repackage a box which has been added.
-      class Repackage < BoxCommand
-        BoxCommand.subcommand "repackage", self
-        description "Repackages a box which has already been added."
-
-        def execute(args=[])
-          args = parse_options(args)
-          return show_help if args.length != 1
-
-          box = Vagrant::Box.find(env, args.first)
-          return error_and_exit(:box_repackage_doesnt_exist) if box.nil?
-          box.repackage(options)
-        end
-
-        def options_spec(opts)
-          opts.banner = "Usage: vagrant box repackage NAME [--output FILENAME] [--include FILES]"
-
-          options["package.output"] = nil
-          options["package.include"] = []
-
-          opts.on("--include x,y,z", Array, "List of files to include in the package") do |v|
-            options["package.include"] = v
-          end
-
-          opts.on("-o", "--output FILE", "File to save the package as.") do |v|
-            options["package.output"] = v
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/destroy.rb

@@ -1,37 +0,0 @@
-module Vagrant
-  class Commands
-    # Destroys 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`.
-    class Destroy < Base
-      Base.subcommand "destroy", self
-      description "Destroys the vagrant environment"
-
-      def execute(args=[])
-        all_or_single(args, :destroy)
-      end
-
-      # Destroys a single VM by name.
-      def destroy_single(name)
-        vm = env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if vm.created?
-          vm.destroy
-        else
-          vm.env.logger.info "VM '#{name}' not created. Ignoring."
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant destroy"
-      end
-    end
-  end
-end

data/lib/vagrant/commands/halt.rb

@@ -1,43 +0,0 @@
-module Vagrant
-  class Commands
-    # 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`.
-    class Halt < Base
-      Base.subcommand "halt", self
-      description "Halts the currently running vagrant environment"
-
-      def execute(args=[])
-        all_or_single(args, :halt)
-      end
-
-      def halt_single(name)
-        vm = env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if vm.created?
-          vm.halt(options)
-        else
-          vm.env.logger.info "VM '#{name}' not created. Ignoring."
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant halt"
-
-        # Defaults
-        options[:force] = false
-
-        opts.on("-f", "--force", "Forceful shutdown of virtual machine.") do |v|
-          options[:force] = true
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/init.rb

@@ -1,36 +0,0 @@
-module Vagrant
-  class Commands
-    class Init < Base
-      Base.subcommand "init", self
-      description "Initializes current folder for Vagrant usage"
-
-      def execute(args)
-        create_vagrantfile(:default_box => args[0] , :default_box_url => args[1])
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant init [name] [box_url]"
-      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
-      # @param [String] :default_box_url The default url for fetching
-      # the given box for the Vagrantfile
-      def create_vagrantfile(opts={})
-        rootfile_path = File.join(Dir.pwd, Environment::ROOTFILE_NAME)
-        error_and_exit(:rootfile_already_exists) if File.exist?(rootfile_path)
-
-        # Set the defaults of the Vagrantfile
-        opts[:default_box] ||= "base"
-
-        File.open(rootfile_path, 'w+') do |f|
-          f.write(TemplateRenderer.render(Environment::ROOTFILE_NAME, opts))
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/package.rb

@@ -1,81 +0,0 @@
-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=[])
-        args = parse_options(args)
-
-        if options[:base]
-          package_base
-        else
-          package_single(args[0])
-        end
-      end
-
-      def package_base
-        # Packaging a base box; that is a VM not tied to a specific
-        # vagrant environment
-        vm = VM.find(options[:base], env)
-        if !vm
-          error_and_exit(:vm_base_not_found, :name => options[:base])
-          return # for tests
-        end
-
-        package_vm(vm)
-      end
-
-      def package_single(name)
-        if name.nil? && env.multivm?
-          error_and_exit(:package_multivm)
-          return
-        end
-
-        vm = if name.nil?
-               env.vms.values.first
-             else
-               env.vms[name.to_sym]
-             end
-
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return
-        elsif !vm.created?
-          error_and_exit(:environment_not_created)
-          return
-        end
-
-        package_vm(vm)
-      end
-
-      def package_vm(vm)
-        vm.package(options)
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant package [--base BASE] [--output FILENAME] [--include FILES]"
-
-        # Defaults
-        options[:base] = nil
-        options["package.output"] = nil
-        options["package.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["package.include"] = v
-        end
-
-        opts.on("-o", "--output FILE", "File to save the package as.") do |v|
-          options["package.output"] = v
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/provision.rb

@@ -1,31 +0,0 @@
-module Vagrant
-  class Commands
-    #run the provisioner on a running vm
-    class Provision < Base
-      Base.subcommand "provision", self
-      description "Run the provisioner"
-
-      def execute(args=[])
-        all_or_single(args, :provision)
-      end
-
-      def provision_single(name)
-        vm = env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if vm.created? && vm.vm.running?
-          vm.provision
-        else
-          vm.env.logger.info "VM '#{name}' not running. Ignoring provision request."
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant provision"
-      end
-    end
-  end
-end

data/lib/vagrant/commands/reload.rb

@@ -1,36 +0,0 @@
-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_root_path
-        all_or_single(args, :reload)
-      end
-
-      def reload_single(name)
-        vm = env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if vm.created?
-          vm.reload
-        else
-          vm.env.logger.info "VM '#{name}' not created. Ignoring."
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant reload"
-      end
-    end
-  end
-end

data/lib/vagrant/commands/resume.rb

@@ -1,35 +0,0 @@
-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=[])
-        all_or_single(args, :resume)
-      end
-
-      def resume_single(name)
-        vm = env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if vm.created?
-          vm.resume
-        else
-          vm.env.logger.info "VM '#{name}' not created. Ignoring."
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant resume"
-      end
-    end
-  end
-end

data/lib/vagrant/commands/ssh.rb

@@ -1,78 +0,0 @@
-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=[])
-        args = parse_options(args)
-        if !options[:execute].empty?
-          vms = args[0] ? {args[0] => env.vms[args[0].to_sym]} : env.vms
-          vms.each do |name, vm|
-            ssh_execute(name, vm)
-          end
-        else
-          ssh_connect(args[0])
-        end
-      end
-
-      def ssh_execute(name, vm)
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        elsif !vm.created?
-          error_and_exit(:environment_not_created)
-          return
-        end
-
-        vm.ssh.execute do |ssh|
-          options[:execute].each do |command|
-            vm.env.logger.info("Execute: #{command}")
-            ssh.exec!(command) do |channel, type, data|
-              # TODO: Exit status checking?
-              vm.env.logger.info("#{type}: #{data}")
-            end
-          end
-        end
-      end
-
-      def ssh_connect(name)
-        if name.nil? && env.multivm?
-          if env.primary_vm.nil?
-            error_and_exit(:ssh_multivm)
-            return # for tests
-          end
-        end
-
-        vm = name.nil? ? env.primary_vm :  env.vms[name.to_sym]
-        if vm.nil?
-          error_and_exit(:unknown_vm, :vm => name)
-          return # for tests
-        end
-
-        if !vm.created?
-          error_and_exit(:environment_not_created)
-          return
-        else
-          vm.ssh.connect
-        end
-      end
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant ssh [--execute COMMAND]"
-
-        # Defaults
-        options[:execute] = []
-
-        opts.on("-e", "--execute COMMAND", "A command to execute. Multiple -e's may be specified.") do |value|
-          options[:execute] << value
-        end
-      end
-    end
-  end
-end