veewee 0.3.1 → 0.3.2

data/lib/veewee/provider/core/helper/web.rb

@@ -9,13 +9,14 @@ module Veewee
 
           class FileServlet < WEBrick::HTTPServlet::AbstractServlet
 
-            attr_reader :ui
+            attr_reader :ui, :threaded
 
-            def initialize(server,localfile,ui)
+            def initialize(server,localfile,ui,threaded)
               super(server)
               @server=server
               @localfile=localfile
               @ui=ui
+              @threaded=threaded
             end
 
             def do_GET(request,response)
@@ -30,18 +31,27 @@ module Veewee
                 ui.info "Serving file #{@localfile}"
                 content
               end
-              #If we shut too fast it might not get the complete file
-              sleep 2
-              @server.shutdown
+              if not @threaded
+                ui.info "Shutting down for #{@localfile}"
+                @server.shutdown
+              end
             end
           end
 
         end
         module Web
 
-          def wait_for_http_request(filename,options={:timeout => 10, :web_dir => "", :port => 7125})
+          def wait_for_http_request(filename,options) # original blocking
+            s = server_for_http_request(filename,options)
+            s.start
+          end
 
+          def allow_for_http_request(filename,options) # start in new thread
+            s = server_for_http_request(filename,options.merge({:threaded => true}))
+            Thread.new { s.start }
+          end
 
+          def server_for_http_request(filename,options={:timeout => 10, :web_dir => "", :port => 7125, :threaded => false})
             # Calculate the OS equivalent of /dev/null , on windows this is NUL:
             # http://www.ruby-forum.com/topic/115472
             fn = test(?e, '/dev/null') ? '/dev/null' : 'NUL:'
@@ -55,14 +65,15 @@ module Veewee
               :Logger => webrick_logger,
               :AccessLog => webrick_logger
             )
-            env.logger.debug("mounting file /#{filename}")
-            s.mount("/#{filename}", Veewee::Provider::Core::Helper::Servlet::FileServlet,File.join(web_dir,filename),ui)
+            mount_filename = filename.start_with?('/') ? filename : "/#{filename}"
+            env.logger.debug("mounting file #{mount_filename}")
+            s.mount("#{mount_filename}", Veewee::Provider::Core::Helper::Servlet::FileServlet,File.join(web_dir,filename),ui,options[:threaded])
             trap("INT"){
               s.shutdown
               ui.info "Stopping webserver"
               exit
             }
-            s.start
+            s
           end
 
         end #Class

data/lib/veewee/provider/core/helper/winrm.rb

@@ -0,0 +1,167 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+
+        class WinrmResult
+          attr_accessor :stdout
+          attr_accessor :stderr
+          attr_accessor :status
+
+          def initialize(stdout,stderr,status)
+            @stdout=stdout
+            @stderr=stderr
+            @status=status
+          end
+        end
+
+        module Winrm
+
+          require 'timeout'
+          require 'log4r'
+          require 'em-winrm'
+          require 'highline'
+
+          def winrm_up?(ip,options)
+            begin
+              if not @winrm_up
+                @httpcli = HTTPClient.new(:agent_name => 'Ruby WinRM Client')
+                @httpcli.receive_timeout = 10
+                @httpcli.set_auth(nil, options[:user], options[:pass])
+                @httpcli.get("http://#{ip}:#{options[:port]}/wsman")
+                @winrm_up = true
+              end
+            rescue HTTPClient::ReceiveTimeoutError,HTTPClient::ConnectTimeoutError
+              @winrm_up = false
+            end
+          end
+
+
+          def when_winrm_login_works(ip="127.0.0.1", options = {}, &block)
+
+            #options=winrm_options.merge(options.merge({:operation_timeout => 5}))
+            options=winrm_options.merge(options)
+            @login_works ||= {}
+            begin
+              Timeout::timeout(options[:timeout]) do
+                if @login_works[ip]
+                  block.call(ip);
+                else
+                  env.ui.info  "Waiting for winrm login on #{ip} with user #{options[:user]} to windows on port => #{options[:port]} to work, timeout=#{options[:timeout]} sec"
+                  until @connected do
+                    begin
+                      sleep 1
+                      env.ui.info ".",{:new_line => false}
+                      next if not winrm_up?(ip, options)
+                      winrm_execute(ip,"hostname",options.merge({:progress => nil}))
+                      @login_works[ip]=true
+                      env.ui.info "\n"
+                      block.call(ip);
+                      env.ui.info ""
+                      sleep 1
+                      @connected = true
+                      return true
+                    rescue Exception => e
+                      puts e.inspect
+                      puts e.message
+                      puts e.backtrace.inspect
+                      sleep 5
+                    end
+                  end
+                end
+              end
+            rescue Timeout::Error
+              env.ui.error "Winrm timeout #{options[:timeout]} sec has been reached."
+              exit -1
+            rescue WinRM::WinRMHTTPTransportError => e
+              if e.message =~ /401/
+                env.ui.error "Unable to authenticate as '#{options[:user]}' with password '#{options[:pass]}'"
+              else
+                raise e
+              end
+            end
+            return false
+          end
+
+
+          def winrm_transfer_file(host,filename,destination = '.' , options = {})
+            options = winrm_options.merge(options.merge({:paranoid => false }))
+            # when_winrm_login_works
+
+            env.ui.info "FIXME: Transferring #{filename} to #{destination} "
+            # print these out while uploading:
+            env.ui.info ".",{:new_line => false}
+            # t::SSH.start( host,options[:user],options )
+            env.ui.info ""
+          end
+
+          def new_session(host,options)
+            opts = winrm_options.merge(options)
+            # create a session
+            begin
+              endpoint = "http://#{host}:#{opts[:port]}/wsman"
+              client = ::WinRM::WinRMWebService.new(endpoint, :plaintext, opts)
+              if opts[:operation_timeout]
+                client.set_timeout(opts[:operation_timeout])
+              end
+            rescue ::WinRM::WinRMAuthorizationError => error
+              raise ::WinRM::WinRMAuthorizationError.new("#{error.message}@#{host}")
+            end
+            client
+          end
+
+          def winrm_execute(host,command, options)
+
+            options = winrm_options.merge( # global default
+                                          { # function defaults
+                                            :exitcode => "0",
+                                            :progress => "on"
+                                          }.merge(
+                                            options # calling override
+                                          ))
+                                          stdout=""
+                                          stderr=""
+                                          status=-99999
+
+                                          @session ||= new_session(host, options)
+
+                                          env.ui.info "Executing winrm command: #{command}" if options[:progress]
+
+                                          @remote_id ||= @session.open_shell
+                                          command_id = @session.run_command(@remote_id, command)
+                                          output = @session.get_command_output(@remote_id, command_id) do |out,error|
+                                            if out
+                                              stdout += out
+                                              env.ui.info out,{:new_line => false} if options[:progress]
+                                            end
+                                            if error
+                                              stderr += error
+                                              env.ui.info error,{:new_line => false} if options[:progress]
+                                            end
+                                          end
+                                          status = output[:exitcode]
+                                          @session.close_shell(@remote_id)
+                                          @remote_id = nil
+                                          # env.ui.info "EXITCODE: #{status}" if status > 0
+                                          # @session.unbind
+                                          # FIXME: May want to look for a list of possible exitcodes
+                                          if (status.to_s != options[:exitcode] )
+                                            if (options[:exitcode]=="*")
+                                              #its a test so we don't need to worry
+                                            else
+                                              raise "Exitcode was not what we expected"
+                                            end
+
+                                          end
+
+                                          return Veewee::Provider::Core::Helper::WinrmResult.new(stdout,stderr,status)
+
+          end
+
+
+
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module

data/lib/veewee/provider/kvm/box/create.rb

@@ -16,17 +16,73 @@ module Veewee
 
         def create_server(options)
           #memory_size,cpu_count, volume_size
-          s=@connection.servers.create(
+          # verify some stuff before trying to create the server
+          kvm_options = definition.kvm[:vm_options][0]
+          # Create the "server"
+          attributes = {
             :name => name,
             :memory_size => definition.memory_size.to_i*1024,
             :cpus => definition.cpu_count.to_i,
             :volume_capacity => "#{definition.disk_size}M",
             :domain_type => options['use_emulation'] ? 'qemu': 'kvm',
-            :network_interface_type => "network",
             :iso_file => definition.iso_file,
             :arch => definition.os_type_id.end_with?("_64") ? "x86_64" : "i686",
             :iso_dir => env.config.veewee.iso_dir
-          )
+          }
+          # Check for network stuff (default, bridge)
+          check_network(kvm_options, attributes)
+          # Check for pool (storage)
+          check_pool(kvm_options, attributes)
+          s=@connection.servers.create(attributes)
+        end
+
+        # Check the network availability of the defined network for kvm
+        def check_network(options, attributes)
+          env.logger.info "Checking network"
+          if options.nil? or options.empty? or options["network_type"].nil? or options["network_type"] == "network"
+            check_default_network
+            attributes[:network_interface_type] = "network"
+          elsif options["network_type"] == "bridge"
+            options["network_bridge_name"].nil?
+            if options["network_bridge_name"].nil?
+              raise Veewee::Error, "You need to specify a 'network_bridge_name' if you plan to use 'bridge' as network type"
+            else
+              attributes[:network_interface_type] = "bridge"
+              attributes[:network_bridge_name] = "#{options["network_bridge_name"]}"
+            end
+          else
+            raise Veewee::Error, "You specified a 'network_type' that isn't known (#{options["network_type"]})"
+          end
+        end
+
+        def check_default_network
+          # Nothing specified, we check for default network
+          conn = ::Libvirt::open("qemu:///system")
+          networks=conn.list_networks
+          if networks.count < 1
+            raise Veewee::Error, "You need at least one (active) network defined or customize your definition. This needs to be available if you connect to qemu:///system."
+          end
+        end
+
+        # Check the given pool and append to attributes
+        # Note: volume_pool_name is not working in fog library version 1.7.0.
+        #       This should be fixed in the next release.
+        def check_pool(options, attributes)
+          env.logger.info "Checking pool storage"
+          if not options.nil? and not options.empty? and not options["pool_name"].nil?
+            conn = ::Libvirt::open("qemu:///system")
+            # Checking if the pool exists and if it is active
+            begin
+              storage = conn.lookup_storage_pool_by_name(options["pool_name"])
+            rescue Libvirt::RetrieveError
+              raise Veewee::Error, "You've specified an non-existent storage pool (#{options["pool_name"]})"
+            end
+            if storage.active?
+              attributes[:volume_pool_name] = options["pool_name"]
+            else
+              raise Veewee::Error, "The storage pool '#{options["pool_name"]}' is not started. Start it and restart the creation process"
+            end
+          end
         end
 
         # Create the volume of a new vm

data/lib/veewee/provider/kvm/provider.rb

@@ -32,12 +32,12 @@ module Veewee
               raise Veewee::Error,"You need at least one (active) storage pool defined. This needs to be available if you connect to qemu:///system"
             end
 
-            env.logger.info "Checking available networks"
-            networks=conn.list_networks
-            env.logger.info "Networks: #{networks.join(',')}"
-            if networks.count < 1
-              raise Veewee::Error,"You need at least one (active) network defined. This needs to be available if you connect to qemu:///system"
-            end
+            #env.logger.info "Checking available networks"
+            #networks=conn.list_networks
+            #env.logger.info "Networks: #{networks.join(',')}"
+            #if networks.count < 1
+            #  raise Veewee::Error,"You need at least one (active) network defined. This needs to be available if you connect to qemu:///system"
+            #end
 
             # http://www.libvirt.org/html/libvirt-libvirt.html#virGetVersion
             # format major * 1,000,000 + minor * 1,000 + release

data/lib/veewee/provider/parallels/box/helper/buildinfo.rb

@@ -36,7 +36,7 @@ module Veewee
 
           ui.info "About to transfer parallels tools iso buildinfo to the box #{name} - #{ip_address} - #{ssh_options}"
           iso_image=guest_iso_path
-          self.scp(iso_image,File.basename(iso_image))
+          self.copy_to_box(iso_image,File.basename(iso_image))
         end
 
       end

data/lib/veewee/provider/virtualbox/box.rb

@@ -14,6 +14,7 @@ require 'veewee/provider/virtualbox/box/helper/ip'
 require 'veewee/provider/virtualbox/box/helper/forwarding'
 require 'veewee/provider/virtualbox/box/helper/natinterface'
 require 'veewee/provider/virtualbox/box/helper/ssh_options'
+require 'veewee/provider/virtualbox/box/helper/winrm_options'
 require 'veewee/provider/virtualbox/box/helper/guest_additions'
 require 'veewee/provider/virtualbox/box/helper/status'
 require 'veewee/provider/virtualbox/box/helper/version'

data/lib/veewee/provider/virtualbox/box/build.rb

@@ -4,14 +4,16 @@ module Veewee
       module BoxCommand
 
         def build(options={})
-          download_vbox_guest_additions_iso(options)
+
+          super(options)
 
           unless definition.floppy_files.nil?
             unless self.shell_exec("java -version").status == 0
               raise Veewee::Error,"This box contains floppyfiles, to create it you require to have java installed or have it in your path"
             end
           end
-          super(options)
+
+          download_vbox_guest_additions_iso(options)
         end
 
       end

data/lib/veewee/provider/virtualbox/box/create.rb

@@ -12,13 +12,6 @@ module Veewee
             raise Veewee::Error,"To create the vm '#{name}' the directory '#{box_directory}' needs to be empty. \nThis could be caused by an badly closed vm.\nRemove it manually before you proceed."
           end
 
-          guessed_port=guess_free_port(definition.ssh_host_port.to_i,definition.ssh_host_port.to_i+40).to_s
-          if guessed_port.to_s!=definition.ssh_host_port
-            env.ui.warn "Changing ssh port from #{definition.ssh_host_port} to #{guessed_port}"
-            definition.ssh_host_port=guessed_port.to_s
-          end
-
-
           # Suppress those annoying virtualbox messages
           self.suppress_messages
 
@@ -36,19 +29,46 @@ module Veewee
           #Create a disk with the same name as the box_name
           self.create_disk
 
+          use_sata = definition.use_sata
+          if use_sata
+            disk_device_number = 0
+            isofile_ide_device_number = 0
+          else
+            disk_device_number = 0
+            isofile_ide_device_number = 1
+          end
+
           self.add_ide_controller
-          self.attach_isofile
+          if use_sata
+            self.add_sata_controller
+            self.attach_disk_sata(disk_device_number)
+          else
+            self.attach_disk_ide(disk_device_number)
+          end
+          self.attach_isofile(isofile_ide_device_number)
           self.attach_guest_additions
 
-          self.add_sata_controller
-          self.attach_disk
-
           self.create_floppy("virtualfloppy.vfd")
 
           self.add_floppy_controller
           self.attach_floppy
 
-          self.add_ssh_nat_mapping
+          if definition.winrm_user && definition.winrm_password # prefer winrm 
+            env.ui.warn "Using winrm because winrm_user and winrm_password are both set"
+            guessed_port=guess_free_port(definition.winrm_host_port.to_i,definition.winrm_host_port.to_i+40).to_s
+            if guessed_port.to_s!=definition.winrm_host_port
+              env.ui.warn "Changing winrm port from #{definition.winrm_host_port} to #{guessed_port}"
+              definition.winrm_host_port=guessed_port.to_s
+            end
+            self.add_winrm_nat_mapping
+          else
+            guessed_port=guess_free_port(definition.ssh_host_port.to_i,definition.ssh_host_port.to_i+40).to_s
+            if guessed_port.to_s!=definition.ssh_host_port
+              env.ui.warn "Changing ssh port from #{definition.ssh_host_port} to #{guessed_port}"
+              definition.ssh_host_port=guessed_port.to_s
+            end
+            self.add_ssh_nat_mapping
+          end
 
         end
 

data/lib/veewee/provider/virtualbox/box/helper/buildinfo.rb

@@ -14,9 +14,12 @@ module Veewee
          #
          def transfer_buildinfo(options)
            super(options)
-           iso_image="VBoxGuestAdditions_#{self.vboxga_version}.iso"
-           env.logger.info "About to transfer virtualbox guest additions iso to the box #{name} - #{ip_address} - #{ssh_options}"
-           self.scp("#{File.join(env.config.veewee.iso_dir,iso_image)}",File.basename(iso_image))
+           # with windows, we just use the mounted volume 
+           if not (definition.winrm_user && definition.winrm_password)
+             iso_image="VBoxGuestAdditions_#{self.vboxga_version}.iso"
+             env.logger.info "About to transfer virtualbox guest additions iso to the box #{name} - #{ip_address} - #{ssh_options}"
+             self.copy_to_box("#{File.join(env.config.veewee.iso_dir,iso_image)}",File.basename(iso_image))
+           end
          end
 
       end