veewee 0.3.0.alpha4 → 0.3.0.alpha5

data/lib/veewee/command.rb

@@ -11,4 +11,5 @@ end
 require 'veewee/command/version'
 require 'veewee/command/kvm'
 require 'veewee/command/virtualbox'
-require 'veewee/command/vmfusion'
+require 'veewee/command/vmfusion'
+require 'veewee/command/parallels'

data/lib/veewee/command/kvm.rb

@@ -2,25 +2,54 @@ module Veewee
   module Command
     class Kvm< Veewee::Command::GroupBase
 
-      register "kvm", "Subcommand for kvm"
-      desc "build [TEMPLATE_NAME] [BOX_NAME]", "Build box"
+      register "kvm", "Subcommand for KVM"
+      desc "build [BOX_NAME]", "Build box"
       method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the build"
       method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
       method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
       method_option :auto,:type => :boolean , :default => false, :aliases => "-a", :desc => "auto answers"
-      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "patterns of postinstall filenames to additionally include"
-      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "patterns of postinstall filenames to exclude"
-      def build(definition_name,box_name=nil)
+      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "ruby regexp of postinstall filenames to additionally include"
+      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "ruby regexp of postinstall filenames to exclude"
+      def build(box_name)
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.config.builders["kvm"].build(definition_name,box_name,options)
+        venv.providers["kvm"].get_box(box_name).build(options)
       end
 
-      desc "destroy [BOXNAME]", "Destroys the virtualmachine that was build"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the destroy" 
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "destroy [BOXNAME]", "Destroys the virtualmachine that was built"
       def destroy(box_name)
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.config.builders["kvm"].get_box(box_name).destroy
+        venv.providers["kvm"].get_box(box_name).destroy(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the shutdown" 
+      desc "halt [BOXNAME]", "Activates a shutdown the virtualmachine"
+      def halt(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["kvm"].get_box(box_name).halt(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "up [BOXNAME]", "Starts a Box"
+      def up(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["kvm"].get_box(box_name).up(options)
+      end
+
+      desc "ssh [BOXNAME] [COMMAND]", "SSH to box"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ssh(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["kvm"].get_box(box_name).issh(command)
       end
 
       desc "define [BOXNAME] [TEMPLATE]", "Define a new basebox starting from a template"
@@ -29,10 +58,10 @@ module Veewee
       def define(definition_name, template_name)
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.define(definition_name,template_name,options)
+        venv.definitions.define(definition_name,template_name,options)
         env.ui.info "The basebox '#{definition_name}' has been succesfully created from the template '#{template_name}'"
         env.ui.info "You can now edit the definition files stored in definitions/#{definition_name} or build the box with:"
-        env.ui.info "veewee vbox build '#{definition_name}'"
+        env.ui.info "veewee kvm build '#{definition_name}'"
       end
 
       desc "undefine [BOXNAME]", "Removes the definition of a basebox "
@@ -43,19 +72,29 @@ module Veewee
           venv=Veewee::Environment.new(options)
           venv.ui=env.ui
           venv.undefine(definition_name,options)
-          venv.info "Definition #{definition_name} succesfully removed"
+          venv.definitions.undefine(definition_name,options)
         rescue Error => ex
           env.ui.error "#{ex}"
           exit -1
         end
       end
 
+      desc "validate [NAME]", "Validates a box against kvm compliancy rules"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def validate(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["kvm"].get_box(box_name).validate_kvm(options)
+      end
+
       desc "ostypes", "List the available Operating System types"
       method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
       def ostypes
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.list_ostypes
+        venv.ostypes.each do |name|
+           env.ui.info "- #{name}"
+        end
       end
 
       desc "templates", "List the currently available templates"
@@ -64,8 +103,8 @@ module Veewee
         env.ui.info "The following templates are available:"
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.get_template_paths.keys.each do |name|
-          env.ui.info "veewee vbox define '<box_name>' '#{name}'"
+        venv.templates.each do |name,template|
+          env.ui.info "veewee kvm define '<box_name>' '#{name}'",:prefix => false
         end
       end
 
@@ -75,7 +114,8 @@ module Veewee
         env.ui.info "The following local definitions are available:"
         venv=Veewee::Environment.new(options)
         venv.ui=env.ui
-        venv.get_definition_paths.keys.each do |name|
+        venv.ui=env.ui
+        venv.definitions.each do |name,definition|
           env.ui.info "- #{name}"
         end
       end

data/lib/veewee/command/parallels.rb

@@ -0,0 +1,124 @@
+module Veewee
+  module Command
+    class Parallels< Veewee::Command::GroupBase
+
+      register "parallels", "Subcommand for Parallels"
+      desc "build [BOX_NAME]", "Build box"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the build"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :auto,:type => :boolean , :default => false, :aliases => "-a", :desc => "auto answers"
+      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "ruby regexp of postinstall filenames to additionally include"
+      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "ruby regexp of postinstall filenames to exclude"
+      def build(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).build(options)
+      end
+
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the destroy" 
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      desc "destroy [BOXNAME]", "Destroys the virtualmachine that was built"
+      def destroy(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).destroy(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the shutdown" 
+      desc "halt [BOXNAME]", "Activates a shutdown the virtualmachine"
+      def halt(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).halt(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "up [BOXNAME]", "Starts a Box"
+      def up(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).up(options)
+      end
+
+      desc "ssh [BOXNAME] [COMMAND]", "SSH to box"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ssh(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).issh(command)
+      end
+
+      desc "define [BOXNAME] [TEMPLATE]", "Define a new basebox starting from a template"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite the definition"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def define(definition_name, template_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.define(definition_name,template_name,options)
+        env.ui.info "The basebox '#{definition_name}' has been succesfully created from the template '#{template_name}'"
+        env.ui.info "You can now edit the definition files stored in definitions/#{definition_name} or build the box with:"
+        env.ui.info "veewee parallels build '#{definition_name}'"
+      end
+
+      desc "undefine [BOXNAME]", "Removes the definition of a basebox "
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def undefine(definition_name)
+        env.ui.info "Removing definition #{definition_name}" , :prefix => false
+        begin
+          venv=Veewee::Environment.new(options)
+          venv.ui=env.ui
+          venv.definitions.undefine(definition_name,options)
+          env.ui.info "Definition #{definition_name} succesfully removed",:prefix => false
+        rescue Error => ex
+          env.ui.error "#{ex}" , :prefix => false
+          exit -1
+        end
+      end
+
+      desc "validate [NAME]", "Validates a box against parallels compliancy rules"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def validate(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["parallels"].get_box(box_name).validate_parallels(options)
+      end
+
+      desc "ostypes", "List the available Operating System types"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ostypes
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.ostypes.each do |name|
+           env.ui.info "- #{name}"
+        end
+      end
+
+      desc "templates", "List the currently available templates"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def templates
+        env.ui.info "The following templates are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.templates.each do |name,template|
+          env.ui.info "veewee parallels define '<box_name>' '#{name}'",:prefix => false
+        end
+      end
+
+      desc "list", "Lists all defined boxes"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def list
+        env.ui.info "The following local definitions are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.each do |name,definition|
+          env.ui.info "- #{name}"
+        end
+      end
+
+
+    end
+
+  end
+end

data/lib/veewee/command/vagrant.rb

@@ -1,108 +1,4 @@
 require 'veewee'
+require 'veewee/command/vagrant/basebox'
 
-module Veewee
-  module Vagrant
-    class Command < ::Vagrant::Command::GroupBase
-
-      register "basebox", "Commands to manage baseboxes"
-      desc "build [TEMPLATE_NAME] [BOX_NAME]", "Build box"
-      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the build"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
-      method_option :auto,:type => :boolean , :default => false, :aliases => "-a", :desc => "auto answers"
-      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "patterns of postinstall filenames to additionally include"
-      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "patterns of postinstall filenames to exclude"
-      def build(definition_name,box_name=nil)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.config.builders["virtualbox"].build(definition_name,box_name,options)
-      end
-
-      desc "destroy [BOXNAME]", "Destroys the virtualmachine that was build"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def destroy(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.config.builders["virtualbox"].get_box(box_name).destroy
-      end
-
-      desc "define [BOXNAME] [TEMPLATE]", "Define a new basebox starting from a template"
-      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite the definition"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def define(definition_name, template_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-
-        venv.define(definition_name,template_name,options)
-        venv.ui.info "The basebox '#{definition_name}' has been succesfully created from the template '#{template_name}'"
-        venv.ui.info "You can now edit the definition files stored in definitions/#{definition_name} or build the box with:"
-        venv.ui.info "vagrant basebox build '#{definition_name}'"
-      end
-
-      desc "undefine [BOXNAME]", "Removes the definition of a basebox "
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def undefine(definition_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        begin
-          venv.ui.info "Removing definition #{definition_name}"
-          venv.undefine(definition_name,options)
-          venv.ui.info "Definition #{definition_name} succesfully removed"
-        rescue Error => ex
-          venv.ui.error"#{ex}"
-          exit -1
-        end
-      end
-
-      desc "templates", "List the currently available templates"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def templates
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.ui.info "The following templates are available:"
-
-        venv.get_template_paths.keys.each do |name|
-          venv.ui.info "vagrant basebox define '<box_name>' '#{name}'"
-        end
-      end
-
-      desc "list", "Lists all defined boxes"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def list
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.ui.info "The following local definitions are available:"
-
-        venv.get_definition_paths.keys.each do |name|
-          venv.ui.info "- #{name}"
-        end
-      end
-
-      desc "ostypes", "List the available Operating System types"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def ostypes
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.list_ostypes
-      end
-
-      desc "validate [NAME]", "Validates a box against vagrant compliancy rules"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def validate(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-
-        venv.config.builders["virtualbox"].validate_vagrant(box_name,options)
-      end
-
-      desc "export [NAME]", "Exports the basebox to the vagrant box format"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def export(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
-        venv.config.builders["virtualbox"].export_vagrant(box_name,options)
-      end
-
-    end
-  end
-end
+Vagrant.commands.register(:basebox)      { Veewee::Command::Vagrant::Basebox }

data/lib/veewee/command/vagrant/basebox.rb

@@ -0,0 +1,82 @@
+require 'veewee'
+require 'optparse'
+require 'veewee/command/vagrant/ostypes'
+require 'veewee/command/vagrant/templates'
+require 'veewee/command/vagrant/list'
+require 'veewee/command/vagrant/build'
+require 'veewee/command/vagrant/destroy'
+require 'veewee/command/vagrant/up'
+require 'veewee/command/vagrant/halt'
+require 'veewee/command/vagrant/ssh'
+require 'veewee/command/vagrant/define'
+require 'veewee/command/vagrant/undefine'
+require 'veewee/command/vagrant/export'
+
+
+module Veewee
+  module Command
+    module Vagrant
+      class Basebox < ::Vagrant::Command::Base
+        def initialize(argv,env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = ::Vagrant::Registry.new
+          @subcommands.register(:ostypes)    { Veewee::Command::Vagrant::Ostypes }
+          @subcommands.register(:templates)    { Veewee::Command::Vagrant::Templates }
+          @subcommands.register(:list)    { Veewee::Command::Vagrant::List }
+          @subcommands.register(:build)    { Veewee::Command::Vagrant::Build }
+          @subcommands.register(:destroy)    { Veewee::Command::Vagrant::Destroy }
+          @subcommands.register(:up)    { Veewee::Command::Vagrant::Up }
+          @subcommands.register(:halt)    { Veewee::Command::Vagrant::Halt }
+          @subcommands.register(:ssh)    { Veewee::Command::Vagrant::Ssh }
+          @subcommands.register(:define)    { Veewee::Command::Vagrant::Define }
+          @subcommands.register(:undefine)    { Veewee::Command::Vagrant::Undefine }
+          @subcommands.register(:export)    { Veewee::Command::Vagrant::Export }
+
+        end
+
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant basebox <command> [<args>]"
+            opts.separator ""
+            opts.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              opts.separator "     #{key}"
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual command run `vagrant basebox COMMAND -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end