veewee-atlassian 0.3.11

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

@@ -0,0 +1,59 @@
+require 'veewee/provider/core/helper/winrm'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+
+        def winrm(command=nil,options={})
+
+          raise Veewee::Error,"Box is not running" unless self.running?
+          winrm_options={:user => definition.winrm_user,:password => definition.winrm_password, :port => definition.winrm_host_port, :exitcode => '*'}
+
+          if (command.nil?)
+            env.ui.info "This is a simple interactive shell"
+            env.ui.info "To exit interactive mode, use 'quit!'"
+
+            while 1
+              command = ui.ask("veewee>")
+              case command.strip
+              when 'quit!'
+                env.ui.info 'Bye!'
+                break
+              else
+                winrm_execute(self.ip_address,command,winrm_options.merge(options))
+              end
+            end
+          else
+            winrm_execute(self.ip_address,command,winrm_options.merge(options))
+          end
+
+
+        end
+
+        private
+        def winrm_options(options)
+
+          command_options = [
+            #"-q", #Suppress warning messages
+            #            "-T", #Pseudo-terminal will not be allocated because stdin is not a terminal.
+            "-p #{winrm_options[:port]}",
+            "-o UserKnownHostsFile=/dev/null",
+            "-t -o StrictHostKeyChecking=no",
+            "-o IdentitiesOnly=yes",
+            "-o VerifyHostKeyDNS=no"
+          ]
+          if !(definition.winrm_key.nil? ||  definition.winrm_key.length!="")
+            command_options << "-i #{definition.winrm_key}"
+          end
+          commandline_options="#{command_options.join(" ")} ".strip
+
+          user_option=definition.winrm_user.nil? ? "" : "-l #{definition.winrm_user}"
+
+          return "#{commandline_options} #{user_option}"
+        end
+      end # Module
+    end # Module
+  end # Module
+end # Module
+

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

@@ -0,0 +1,47 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+
+        module Comm
+
+          def comm_method
+            if (definition.winrm_user && definition.winrm_password)
+              :winrm
+            else
+              :ssh
+            end
+          end
+
+          def when_comm_login_works(ip="127.0.0.1", options = {  } , &block)
+            case comm_method
+            when :winrm
+              when_winrm_login_works(ip,options,block)
+            when :ssh
+              when_ssh_login_works(ip,options,block)
+            end
+          end
+
+          def comm_transfer_file(host,filename,destination = '.' , options = {})
+            case comm_method
+            when :winrm
+              winrm_transfer_file(host,filename,destination,options)
+            when :ssh
+              ssh_transfer_file(host,filename,destination,options)
+            end
+          end
+
+          def comm_execute(host,command, options = { :progress => "on"} )
+            case comm_method
+            when :winrm
+              winrm_execute(host,command, options )
+            when :ssh
+              ssh_execute(host,command, options )
+            end
+          end
+
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,162 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+        module Iso
+
+          require 'open-uri'
+          require 'progressbar'
+          require 'highline/import'
+          require 'digest/md5'
+          require 'digest/sha1'
+
+          def download_iso(url,filename)
+            if !File.exists?(env.config.veewee.iso_dir)
+              ui.info "Creating an iso directory"
+              FileUtils.mkdir(env.config.veewee.iso_dir)
+            end
+            ui.info "Checking if isofile #{filename} already exists."
+            full_path=File.join(env.config.veewee.iso_dir,filename)
+            ui.info "Full path: #{full_path}"
+            if File.exists?(full_path)
+              ui.info ""
+              ui.info "The isofile #{filename} already exists."
+            else
+              download_progress(url,full_path)
+            end
+          end
+
+          def download_progress(url,localfile)
+            pbar = nil
+            URI.parse(url).open(
+              :content_length_proc => lambda {|t|
+              if t && 0 < t
+                pbar = ProgressBar.new("Fetching file", t)
+                pbar.file_transfer_mode
+              end
+            },
+              :progress_proc => lambda {|s|
+              pbar.set s if pbar
+            }) { |src|
+              # We assume large 10K files, so this is tempfile object
+              env.logger.info "#{src.class}"
+                ui.info "Moving #{src.path} to #{localfile}"
+                # Force the close of the src stream to release handle before moving
+                # Not forcing the close may cause an issue on windows (Permission Denied)
+                src.close
+                FileUtils.mv(src.path,localfile)
+                #open(localfile,"wb") { |dst|
+                  #dst.write(src.read)
+                #}
+            }
+          end
+
+          # Compute hash code
+          def hashsum(filename,type)
+            case type
+            when :md5
+              checksum=Digest::MD5.new
+            when :sha1
+              checksum=Digest::SHA1.new
+            else
+              raise Veewee::Error, "Unknown checksum type #{type}"
+            end
+
+            buflen=1024
+            open(filename, "rb") do |io|
+              counter = 0
+              while (!io.eof)
+                readBuf = io.readpartial(buflen)
+                env.ui.info('.',{:new_line => false,:prefix => false }) if ((counter+=1) % 20000 == 0)
+                checksum.update(readBuf)
+              end
+            end
+            return checksum.hexdigest
+          end
+
+          def verify_sum(full_path,type)
+            filename = File.basename(full_path)
+            required_sum = self.instance_variable_get('@iso_'+type.to_s)
+            ui.info "Verifying #{type} checksum : #{self.required_sum}"
+            file_sum = hashsum(full_path,type)
+
+            unless file_sum == required_sum
+              ui.error "The #{type} checksum for file #{filename } do not match: "
+              ui.error "- #{file_sum} (current) vs #{required_sum} (specified)"
+              raise Veewee::Error, "The #{type} checksum for file #{filename } do not match: \n"+ "- #{file_sum} (current) vs #{required_sum} (specified)"
+            end
+          end
+
+          def verify_iso(options)
+            filename=self.iso_file
+            full_path=File.join(env.config.veewee.iso_dir,filename)
+
+            if File.exists?(full_path)
+              ui.info ""
+              ui.info "The isofile #{filename} already exists."
+            else
+
+              path1=Pathname.new(full_path)
+              path2=Pathname.new(Dir.pwd)
+              rel_path=path1.relative_path_from(path2).to_s
+
+              ui.info ""
+              ui.info "We did not find an isofile here : #{full_path}. \n\nThe definition provided the following download information:"
+              unless "#{self.iso_src}"==""
+                ui.info "- Download url: #{self.iso_src}"
+              end
+              ui.info "- Md5 Checksum: #{self.iso_md5}" if self.iso_md5
+              ui.info "- Sha1 Checksum: #{self.iso_sha1}" if self.iso_sha1
+              ui.info "#{self.iso_download_instructions}"
+              ui.info ""
+
+              if self.iso_src == ""
+                ui.info "Please follow the instructions above:"
+                ui.info "- to get the ISO"
+                ui.info" - put it in <currentdir>/iso"
+                ui.info "- then re-run the command"
+                ui.info ""
+                raise Veewee::Error, "No ISO src is available, can't download it automatically"
+              else
+                answer=nil
+                answer="yes" if options["auto"]==true
+                env.logger.info "Auto download enabled?#{answer} #{!options['auto'].nil?}"
+                if answer.nil?
+                  answer=ui.ask("Download? (Yes/No)") {|q| q.default="No"}
+                end
+
+                if answer.downcase == "yes"
+                  begin
+                    download_iso(self.iso_src,filename)
+                  rescue OpenURI::HTTPError => ex
+                    ui.error "There was an error downloading #{self.iso_src}:"
+                    ui.error "#{ex}"
+                    raise Veewee::Error, "There was an error downloading #{self.iso_src}:\n#{ex}"
+                  end
+                else
+                  ui.info "You have selected manual download: "
+                  ui.info "curl -C - -L '#{self.iso_src}' -o '#{rel_path}'"
+                  ui.info "md5 '#{rel_path}' " if self.iso_md5
+                  ui.info "shasum '#{rel_path}' " if self.iso_sha1
+                  ui.info ""
+                  exit
+                end
+
+                unless File.readable?(full_path)
+                  raise Veewee::Error, "The provided iso #{full_path} is not readable"
+                end
+
+              end
+
+            end
+
+            verify_sum(full_path,:md5) if options["checksum"] && !self.iso_md5.nil?
+            verify_sum(full_path,:sha1) if options["checksum"] && !self.iso_sha1.nil?
+
+          end
+        end #Module
+
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,97 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+        class Scancode
+
+          def self.string_to_keycode(thestring)
+
+            #http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
+
+            # keycode hash, seeded with 'Tab' - which is special as it's longer than 1 char
+            k = { 'Tab' => '0f 8f' }
+            
+            # add keycodes
+
+            # "pure" keys (no modifier keys)
+            lower_keys = {
+              '1234567890-='  => 0x02,
+              'qwertyuiop[]'  => 0x10,
+              'asdfghjkl;\'`' => 0x1e,
+              '\\zxcvbnm,./'  => 0x2b
+            }.each do |keys, offset|
+              keys.split('').each_with_index do |key, idx|
+                k[key] = sprintf('%02x %02x', idx + offset, idx + offset + 0x80)
+              end
+            end
+
+            # upcase keys (with shift)
+            {
+              '!@#$%^&*()_+'  => 0x02,
+              'QWERTYUIOP{}'  => 0x10,
+              'ASDFGHJKL:"~'  => 0x1e,
+              '|ZXCVBNM<>?'   => 0x2b
+            }.each do |keys, offset|
+              keys.split('').each_with_index do |key, idx|
+                k[key] = sprintf('2a %02x aa %02x', idx + offset, idx + offset + 0x80)
+              end
+            end
+            
+            special=Hash.new;
+            special['<Enter>'] = '1c 9c';
+            special['<Backspace>'] = '0e 8e';
+            special['<Spacebar>'] = '39 b9';
+            special['<Return>'] = '1c 9c'
+            special['<Esc>'] = '01 81';
+            special['<Tab>'] = '0f 8f';
+            special['<KillX>'] = '1d 38 0e b8';
+            special['<Wait>'] = 'wait';
+
+            special['<Up>'] = '48 c8';
+            special['<Down>'] = '50 d0';
+            special['<PageUp>'] = '49 c9';
+            special['<PageDown>'] = '51 d1';
+            special['<End>'] = '4f cf';
+            special['<Insert>'] = '52 d2';
+            special['<Delete>'] = '53 d3';
+            special['<Left>'] = '4b cb';
+            special['<Right>'] = '4d cd';
+            special['<Home>'] = '47 c7';
+
+            # F1 .. F10
+            (1..10).each { |num| special["<F#{num}>"] = sprintf('%02x', num + 0x3a) }
+
+            keycodes=''
+            thestring.gsub!(/ /,"<Spacebar>")
+
+            until thestring.length == 0
+              nospecial=true;
+              special.keys.each { |key|
+                if thestring.start_with?(key)
+                  #take thestring
+                  #check if it starts with a special key + pop special string
+                  keycodes=keycodes+special[key]+' ';
+                  thestring=thestring.slice(key.length,thestring.length-key.length)
+                  nospecial=false;
+                  break;
+                end
+              }
+              if nospecial
+                code=k[thestring.slice(0,1)]
+                if !code.nil?
+                  keycodes=keycodes+code+' '
+                else
+                  ui.error "no scan code for #{thestring.slice(0,1)}"
+                end
+                #pop one
+                thestring=thestring.slice(1,thestring.length-1)
+              end
+            end
+
+            return keycodes
+          end
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,56 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+
+        class ShellResult
+          attr_accessor :stdout
+          attr_accessor :stderr
+          attr_accessor :status
+
+          def initialize(stdout,stderr,status)
+            @stdout=stdout
+            @stderr=stderr
+            @status=status
+          end
+        end
+
+        module Shell
+
+          # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/185404
+          # This should work on windows too now
+          # This will result in a ShellResult structure with stdout, stderr and status
+          def shell_exec(command,options = {:mute => true,:status => 0,:stderr => "&1"})
+            defaults={:mute => true, :status => 0}
+            options=defaults.merge(options)
+            result=ShellResult.new("","",-1)
+            ui.info "Executing #{command}" unless options[:mute]
+            env.logger.debug "Command: \"#{command}\""
+            env.logger.debug "Output:"
+            env.logger.debug "-------"
+            escaped_command=command
+            stderr_redirect = options[:stderr]? options[:stderr] : "&1"
+            IO.popen("#{escaped_command}"+ " 2>#{stderr_redirect}") { |p|
+              p.each_line{ |l|
+                result.stdout+=l
+                ui.info(l,{:new_line => false})  unless options[:mute]
+                env.logger.debug(l.chomp)
+              }
+              result.status=Process.waitpid2(p.pid)[1].exitstatus
+              if result.status.to_i!=options[:status]
+                ui.error "Error: We executed a shell command and the exit status was not #{options[:status]}"
+                ui.error "- Command :#{command}."
+                ui.error "- Exitcode :#{result.status}."
+                ui.error "- Output   :\n#{result.stdout}"
+                raise Veewee::Error,"Wrong exit code for command #{command}"
+              end
+            }
+            return result
+          end
+
+
+        end #Module
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,165 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+
+        class SshResult < RuntimeError
+          attr_accessor :stdout
+          attr_accessor :stderr
+          attr_accessor :status
+
+          def initialize(stdout,stderr,status)
+            @stdout=stdout
+            @stderr=stderr
+            @status=status
+          end
+        end
+
+        module Ssh
+
+          require 'net/ssh'
+          require 'net/scp'
+
+          def when_ssh_login_works(ip="127.0.0.1", options = {  } , &block)
+
+            defaults={ :port => '22', :timeout => 20000 }
+
+            options=defaults.merge(options)
+            timeout = options[:timeout]
+            timeout=ENV['VEEWEE_TIMEOUT'].to_i unless ENV['VEEWEE_TIMEOUT'].nil?
+
+            ui.info  "Waiting for ssh login on #{ip} with user #{options[:user]} to sshd on port => #{options[:port]} to work, timeout=#{timeout} sec"
+
+            begin
+              Timeout::timeout(timeout) do
+                connected=false
+                while !connected do
+                  begin
+                    env.ui.info ".",{:new_line => false , :prefix => false}
+                    Net::SSH.start(ip, options[:user], { :port => options[:port] , :password => options[:password], :paranoid => false , :timeout => timeout }) do |ssh|
+
+                      ui.info "\n", {:prefix => false}
+                      block.call(ip);
+                      return true
+                    end
+                  rescue Net::SSH::Disconnect, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ENETUNREACH, Errno::ETIMEDOUT
+                    sleep 5
+                  end
+                end
+              end
+            rescue IOError
+              ui.info "Received a disconnect; moving on"
+              sleep 5
+            rescue Timeout::Error
+              raise Veewee::Error, "Ssh timeout #{timeout} sec has been reached."
+            end
+            ui.info ""
+            return false
+          end
+
+
+          def ssh_transfer_file(host,filename,destination = '.' , options = {})
+
+            defaults={ :paranoid => false }
+            options=defaults.merge(options)
+
+            Net::SSH.start( host,options[:user],options ) do |ssh|
+              ui.info "Transferring #{filename} to #{destination} "
+              ssh.scp.upload!( filename, destination ) do |ch, name, sent, total|
+                #   print "\r#{destination}: #{(sent.to_f * 100 / total.to_f).to_i}%"
+                env.ui.info ".",{:new_line => false , :prefix => false}
+              end
+            end
+            ui.info "", {:prefix => false}
+          end
+
+
+          def ssh_execute(host,command, options = { :progress => "on"} )
+            defaults= { :port => "22", :exitcode => "0", :user => "root"}
+            options=defaults.merge(options)
+            pid=""
+            stdin=command
+            stdout=""
+            stderr=""
+            status=-99999
+
+            ui.info "Executing command: #{command}"
+
+            Net::SSH.start(host, options[:user], { :port => options[:port], :password => options[:password], :paranoid => false }) do |ssh|
+
+              # open a new channel and configure a minimal set of callbacks, then run
+              # the event loop until the channel finishes (closes)
+              channel = ssh.open_channel do |ch|
+
+                #request pty for sudo stuff and so
+                ch.request_pty do |ch, success|
+                  raise "Error requesting pty" unless success
+                end
+
+                ch.exec "#{command}" do |ch, success|
+                  raise "could not execute command" unless success
+
+
+                  # "on_data" is called when the process writes something to stdout
+                  ch.on_data do |c, data|
+                    stdout+=data
+
+                    ui.info data
+
+                  end
+
+                  # "on_extended_data" is called when the process writes something to stderr
+                  # NOTE: When requesting a pty (ch.request_pty), everything goes to stdout
+                  ch.on_extended_data do |c, type, data|
+                    stderr+=data
+
+                    ui.info data
+
+                  end
+
+                  #exit code
+                  #http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/a806b0f5dae4e1e2
+                  channel.on_request("exit-status") do |ch, data|
+                    exit_code = data.read_long
+                    status=exit_code
+                    if exit_code > 0
+                      ui.info "ERROR: exit code #{exit_code}"
+                    else
+                      #ui.info "Successfully executed"
+                    end
+                  end
+
+                  channel.on_request("exit-signal") do |ch, data|
+                    ui.info "SIGNAL: #{data.read_long}"
+                  end
+
+                  ch.on_close {
+                    #ui.info "done!"
+                  }
+                  #status=ch.exec "echo $?"
+                end
+              end
+              channel.wait
+            end
+
+
+            if (status.to_s != options[:exitcode] )
+              if (options[:exitcode]=="*")
+                #its a test so we don't need to worry
+              else
+                raise Veewee::Provider::Core::Helper::SshResult.new(stdout,stderr,status), "Exitcode was not what we expected"
+              end
+
+            end
+
+            return Veewee::Provider::Core::Helper::SshResult.new(stdout,stderr,status)
+
+          end
+
+
+
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module