veewee 0.3.7 → 0.3.9

data/lib/veewee/command/fusion.rb

@@ -3,169 +3,43 @@
 module Veewee
   module Command
     class Fusion < Veewee::Command::GroupBase
-      register "add_share", "Adds a Share to the Guest"
-      desc "add_share [BOX_NAME] [SHARE_NAME] [SHARE_PATH]", "hello"
-      def add_share(box_name, share_name, share_path)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-#          command="#{File.dirname().shellescape}/vmware-vdiskmanager -c -s #{definition.disk_size}M -a lsilogic -t #{disk_type} #{name}.vmdk"
-#          shell_results=shell_exec("#{command}",{:mute => true})
-        venv.providers["vmfusion"].get_box(box_name).add_share(share_name, share_path)
-        
-      end
-    end
 
-    class Fusion< Veewee::Command::GroupBase
+      register :command => "fusion",
+        :description => "Subcommand for Vmware fusion",
+        :provider => "vmfusion"
 
-      register "fusion", "Subcommand for Vmware fusion"
       desc "build [BOX_NAME]", "Build box"
+      # TODO move common build options into array
       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 :checksum , :type => :boolean , :default => false, :desc => "verify checksum"
       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["vmfusion"].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"
-      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.providers["vmfusion"].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["vmfusion"].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["vmfusion"].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["vmfusion"].get_box(box_name).issh(command)
-      end
-
-
-      desc "winrm [BOXNAME] [COMMAND]", "Execute command via winrm"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def winrm(box_name,command=nil)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["vmfusion"].get_box(box_name).winrm(command,{:exitcode => "*"})
+        env.get_box(box_name).build(options)
       end
 
-      desc "copy [BOXNAME] [SRC] [DST]", "Copy a file to the VM"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def copy(box_name,src,dst)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["vmfusion"].get_box(box_name).copy_to_box(src,dst)
-      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 successfully 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 fusion 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} successfully removed",:prefix => false
-        rescue Error => ex
-          env.ui.error "#{ex}" , :prefix => false
-          exit -1
-        end
-      end
-
-      desc "validate [NAME]", "Validates a box against vmfusion compliancy rules"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      desc "validate [BOX_NAME]", "Validates a box against vmfusion compliancy rules"
       method_option :tags, :type => :array , :default => %w{vmfusion puppet chef}, :aliases => "-t", :desc => "tags to validate"
       def validate(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["vmfusion"].get_box(box_name).validate_vmfusion(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
+        env.get_box(box_name).validate_vmfusion(options)
       end
 
-      desc "export [NAME]", "Exports the basebox to the ova format"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      desc "export [BOX_NAME]", "Exports the basebox to the vagrant format"
       method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite existing file"
+      method_option :export_type, :type => :string, :default => "vagrant", :desc => "export into vmware ova or vagrant box format"
       def export(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["vmfusion"].get_box(box_name).export_ova(options)
+        env.get_box(box_name).export_vmfusion(options)
       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 fusion 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
+      desc "add_share [BOX_NAME] [SHARE_NAME] [SHARE_PATH]", "Adds a share to the guest"
+      def add_share(box_name, share_name, share_path)
+#          command="#{File.dirname().shellescape}/vmware-vdiskmanager -c -s #{definition.disk_size}M -a lsilogic -t #{disk_type} #{name}.vmdk"
+#          shell_results=shell_exec("#{command}",{:mute => true})
+        env.get_box(box_name).add_share(share_name, share_path)
       end
 
-
     end
-
   end
 end

data/lib/veewee/command/group_base.rb

@@ -1,5 +1,6 @@
 require 'thor'
 require 'thor/actions'
+require 'veewee/environment'
 
 module Veewee
   module Command
@@ -66,6 +67,12 @@ module Veewee
       include Thor::Actions
       include Helpers
 
+      class_option :debug,:type => :boolean , :default => false, :desc => "enable debugging"
+
+      class_option :cwd, :aliases => ['-w', '--workdir'],  :type => :string,
+                   :default => Veewee::Environment.workdir,
+                   :desc => "Change the working directory. (The folder containing the definitions folder)."
+
       attr_reader :env
 
       # Register the command with the main Veewee CLI under the given
@@ -83,20 +90,117 @@ module Veewee
       #  for the same command. For example, `veewee version` is also
       #  `veewee --version` and `veewee -v`
       #
-      # @param [String] usage
-      # @param [String] description
-      # @param [Hash] opts
-      def self.register(usage, description, opts=nil)
-        @_name = Base.extract_name_from_usage(usage)
-        CLI.register(self, @_name, usage, description, opts)
+      def self.register(options = {})
+        # self refers to the class object of the provider subclass
+        self.class_variable_set(:@@command, options[:command])
+        self.class_variable_set(:@@description, options[:description])
+        self.class_variable_set(:@@provider, options[:provider])
+        CLI.register(self, options[:command], options[:command], options[:description], options[:opts])
       end
 
       def initialize(*args)
         super
+        # make provider class variables easily available to global task methods
+        @command = self.class.class_variable_get(:@@command)
+        @description = self.class.class_variable_get(:@@description)
+        @provider = self.class.class_variable_get(:@@provider)
         initialize_environment(*args)
+        @env.current_provider = @provider
+      end
+
+      desc "templates", "List the currently available templates"
+      method_option :box_name, :default => '<box_name>', :aliases => ['-b'], :desc => "Name of the box you want create."
+      def templates
+        env.ui.info "The following templates are available:",:prefix => false
+        env.templates.each do |name,template|
+          env.ui.info "veewee #{@command} define '#{options[:box_name]}' '#{name}' --workdir=#{options[:cwd]}",:prefix => false
+        end
+      end
+
+      desc "list", "Lists all defined boxes"
+      def list
+        venv=env
+        env.ui.info "The following definitions are available in #{venv.cwd}: ",:prefix => false
+        venv.definitions.each do |name,definition|
+          env.ui.info "- #{name}",:prefix => false
+        end
+      end
+
+      desc "define [BOX_NAME] [TEMPLATE]", "Define a new basebox starting from a template"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite the definition"
+      def define(definition_name, template_name)
+        begin
+          env.definitions.define(definition_name,template_name,options)
+          env.ui.info "The basebox '#{definition_name}' has been successfully created from the template '#{template_name}'"
+          env.ui.info "You can now edit the definition files stored in #{options[:cwd]}/definitions/#{definition_name} or build the box with:"
+          env.ui.info "veewee #{@command} build '#{definition_name}' --workdir=#{options[:cwd]}"
+        rescue Error => ex
+          env.ui.error("#{ex}",:prefix => false)
+          exit -1
+        end
+      end
+
+      desc "winrm [BOX_NAME] [COMMAND]", "Execute command via winrm"
+      def winrm(box_name, command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).winrm(command,{:exitcode => "*"})
+      end
+
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the destroy"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "destroy [BOX_NAME]", "Destroys the virtualmachine that was built"
+      def destroy(box_name)
+        env.get_box(box_name).destroy(options)
+      end
+
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the shutdown"
+      desc "halt [BOX_NAME]", "Activates a shutdown the virtualmachine"
+      def halt(box_name)
+        env.get_box(box_name).halt(options)
+      end
+
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "up [BOX_NAME]", "Starts a Box"
+      def up(box_name)
+        env.get_box(box_name).up(options)
+      end
+
+      desc "ssh [BOX_NAME] [COMMAND]", "SSH to box"
+      def ssh(box_name, command=nil)
+        env.get_box(box_name).issh(command)
+      end
+
+      desc "copy [BOX_NAME] [SRC] [DST]", "Copy a file to the VM"
+      def copy(box_name, src, dst)
+        env.get_box(box_name).copy_to_box(src,dst)
+      end
+
+      desc "undefine [BOX_NAME]", "Removes the definition of a basebox "
+      def undefine(definition_name)
+        env.ui.info "Removing definition #{definition_name}" , :prefix => false
+        begin
+          env.definitions.undefine(definition_name,options)
+          env.ui.info "Definition #{definition_name} successfully removed",:prefix => false
+        rescue Error => ex
+          env.ui.error "#{ex}" , :prefix => false
+          exit -1
+        end
+      end
+
+      desc "ostypes", "List the available Operating System types"
+      def ostypes
+        env.ostypes.each do |name|
+          env.ui.info "- #{name}"
+        end
+      end
+
+      desc "sendkeys [BOX_NAME] [SEQUENCE]", "Sends the key sequence (comma separated) to the box. E.g for testing the :boot_cmd_sequence"
+      def sendkeys(box_name, sequence)
+        env.get_box(box_name).console_type(sequence.split(","))
       end
 
-      protected
+protected
 
       # Override the basename to include the subcommand name.
       def self.basename

data/lib/veewee/command/kvm.rb

@@ -1,127 +1,42 @@
 module Veewee
   module Command
-    class Kvm< Veewee::Command::GroupBase
+    class Kvm < Veewee::Command::GroupBase
+
+      register :command => "kvm",
+               :description => "Subcommand for KVM",
+               :provider => "kvm"
 
-      register "kvm", "Subcommand for KVM"
       desc "build [BOX_NAME]", "Build box"
+      # TODO move common build options into array
       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 :checksum , :type => :boolean , :default => false, :desc => "verify checksum"
       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"
+
       method_option :use_emulation, :type => :boolean , :default => false, :desc => "Use QEMU emulation"
+      method_option :pool_name, :type => :string, :default => nil, :desc => "Name of the libvirt storage pool to be used"
+      method_option :network_name, :type => :string, :default => "default", :desc => "Name of the libvirt network to be used"
       def build(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["kvm"].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"
-      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.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"
-      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 successfully 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 kvm build '#{definition_name}'"
+        env.get_box(box_name).build(options)
       end
 
-      desc "undefine [BOXNAME]", "Removes the definition of a basebox "
+      desc "export [BOX_NAME]", "Exports the basebox to the vagrant-libvirt format"
       method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
-      def undefine(definition_name)
-        env.ui.info "Removing definition #{definition_name}"
-        begin
-          venv=Veewee::Environment.new(options)
-          venv.ui=env.ui
-          venv.undefine(definition_name,options)
-          venv.definitions.undefine(definition_name,options)
-        rescue Error => ex
-          env.ui.error("#{ex}", :prefix=> false)
-          exit -1
-        end
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite existing file"
+      method_option :sparsify,:type => :boolean , :default => false, :desc => "use virt-sparsify to minimize image size"
+      method_option :vagrantfile,:type => :string , :default => "", :desc => "specify Vagrantfile"
+      def export(box_name)
+       env.get_box(box_name).export_vagrant(options)
       end
 
-      desc "validate [NAME]", "Validates a box against kvm compliancy rules"
-      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      desc "validate [BOX_NAME]", "Validates a box against kvm compliancy rules"
       method_option :tags,:type => :array , :default => %w{kvm puppet chef}, :aliases => "-t", :desc => "tags to validate"
       def validate(box_name)
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.providers["kvm"].get_box(box_name).validate_kvm(options)
+        env.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.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:"
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.templates.each do |name,template|
-          env.ui.info "veewee kvm 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:"
-        venv=Veewee::Environment.new(options)
-        venv.ui=env.ui
-        venv.ui=env.ui
-        venv.definitions.each do |name,definition|
-          env.ui.info "- #{name}"
-        end
-      end
     end
-
   end
 end