veewee-atlassian 0.3.11

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

@@ -0,0 +1,29 @@
+require 'veewee/provider/core/helper/ssh'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def scp(localfile,remotefile,options={})
+          raise Veewee::Error,"Box is not running" unless self.running?
+          begin
+            new_options=ssh_options.merge(options)
+            self.when_ssh_login_works(self.ip_address,new_options) do
+              begin
+                env.logger.info "About to transfer #{localfile} to #{remotefile} to the box #{name} - #{self.ip_address} - #{new_options.inspect}"
+                self.ssh_transfer_file(self.ip_address,localfile,remotefile,new_options)
+              rescue RuntimeError => ex
+                ui.error("Error transfering file #{localfile} failed, possible not enough permissions to write? #{ex}",:prefix => false)
+                raise Veewee::SshError,ex
+              end
+            end
+          rescue Net::SSH::AuthenticationFailed => ex
+            ui.error("Authentication failure",:prefix => false)
+            raise Veewee::SshError,ex
+          end
+
+        end
+      end # Module
+    end # Module
+  end # Module
+end # Module

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

@@ -0,0 +1,95 @@
+require 'veewee/provider/core/helper/ssh'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+
+        def ssh(command=nil,options={})
+
+          raise Veewee::Error,"Box is not running" unless self.running?
+
+          if (options[:interactive]==true)
+            # Command line options
+            extended_command="#{command}"
+            host_ip=self.ip_address
+
+            unless host_ip.nil? || host_ip==""
+              ssh_command="ssh #{ssh_commandline_options(options)} #{host_ip} \"#{extended_command}\""
+
+              fg_exec(ssh_command,options)
+
+            else
+              ui.error("Can't ssh into '#{@name} as we couldn't figure out it's ip-address",:prefix => false)
+            end
+          else
+            ssh_options={:user => definition.ssh_user,:password => definition.ssh_password, :port => definition.ssh_host_port}
+            ssh_execute(host_ip,command,ssh_options)
+          end
+
+        end
+
+        private
+        def ssh_commandline_options(options)
+
+          command_options = [
+            #"-q", #Suppress warning messages
+            #            "-T", #Pseudo-terminal will not be allocated because stdin is not a terminal.
+            "-p #{ssh_options[:port]}",
+            "-o UserKnownHostsFile=/dev/null",
+            "-t -o StrictHostKeyChecking=no",
+            "-o IdentitiesOnly=yes",
+            "-o VerifyHostKeyDNS=no"
+          ]
+          if !(definition.ssh_key.nil? ||  definition.ssh_key.length!="")
+            command_options << "-i #{definition.ssh_key}"
+          end
+          commandline_options="#{command_options.join(" ")} ".strip
+
+          user_option=definition.ssh_user.nil? ? "" : "-l #{definition.ssh_user}"
+
+          return "#{commandline_options} #{user_option}"
+        end
+
+
+        def fg_exec(ssh_command,options)
+          # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
+          # (GH-51). As a workaround, we fork and wait. On all other platforms,
+          # we simply exec.
+          pid = nil
+          pid = fork if Platform.leopard? || Platform.tiger?
+
+          env.logger.info "Executing internal ssh command"
+          env.logger.info ssh_command
+          Kernel.exec ssh_command if pid.nil?
+          Process.wait(pid) if pid
+        end
+
+        # Shameless copy of vagrant
+        class Platform
+          class << self
+            def tiger?
+              platform.include?("darwin8")
+            end
+
+            def leopard?
+              platform.include?("darwin9")
+            end
+
+            [:darwin, :bsd, :linux].each do |type|
+              define_method("#{type}?") do
+                platform.include?(type.to_s)
+              end
+            end
+
+            def platform
+              RbConfig::CONFIG["host_os"].downcase
+            end
+          end
+        end
+
+      end # Module
+    end # Module
+  end # Module
+end # Module
+

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

@@ -0,0 +1,21 @@
+module Veewee
+  module Provider
+    module Core
+      module BoxCommand
+
+        def sudo(scriptname)
+          if definition.ssh_user=="root"
+            return "#{scriptname}"
+          else
+            command=definition.sudo_cmd
+            newcommand=command.gsub(/%p/,"#{definition.ssh_password}")
+            newcommand.gsub!(/%u/,"#{definition.ssh_user}")
+            newcommand.gsub!(/%f/,"#{scriptname}")
+            return newcommand
+          end
+        end
+
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,64 @@
+module Veewee
+  module Provider
+    module Core
+      module BoxCommand
+
+        def validate_tags(tags,options)
+
+          unless self.exists?
+            ui.error "Error:: You tried to validate box '#{name}' but it does not exist"
+            exit -1
+          end
+
+          unless self.running?
+            ui.error "Error:: You tried to validate box '#{name}' but it is not running"
+            exit -1
+          end
+
+          require 'cucumber'
+
+          require 'cucumber/rspec/disable_option_parser'
+          require 'cucumber/cli/main'
+
+          # Passing ssh options via ENV varialbles to cucumber
+          # VEEWEE_SSH_USER, VEEWEE_SSH_PASSWORD ,VEEWEE_SSH_PORT
+          cucumber_vars=ssh_options
+          cucumber_vars.each do |key,value|
+            ENV['VEEWEE_'+key.to_s.upcase]=cucumber_vars[key].to_s
+          end
+
+          # Pass the name of the box
+          ENV['VEEWEE_BOXNAME']=@name
+          ENV['VEEWEE_PROVIDER']=@provider.name
+
+          if definition.winrm_user && definition.winrm_password # prefer winrm 
+            featurefile="veewee-windows.feature"
+          else
+            featurefile="veewee.feature"
+          end
+
+          feature_path=File.join(File.dirname(__FILE__),"..","..","..","..","..","validation",featurefile)
+
+          features=Array.new
+          features[0]=feature_path
+          features << "--tags"
+          features << tags.map {|t| "@#{t}"}.join(',')
+
+          begin
+            # The dup is to keep ARGV intact, so that tools like ruby-debug can respawn.
+            failure = Cucumber::Cli::Main.execute(features.dup)
+            Kernel.exit(failure ? 1 : 0)
+          rescue SystemExit => e
+            Kernel.exit(e.status)
+          rescue Exception => e
+            ui.error("#{e.message} (#{e.class})")
+            ui.error(e.backtrace.join("\n"))
+            Kernel.exit(1)
+          end
+
+        end
+      end #Module
+
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,122 @@
+# Include the gem library
+require 'net/vnc'
+
+# Monkey patch the vnc
+require 'net/vnc/vnc.rb'
+
+module Veewee
+  module Provider
+    module Core
+      module BoxCommand
+
+      def vnc_type(sequence,host,display=20)
+        counter=0
+        env.logger.info "Opening VNC #{host} on display #{display}"
+        vnc=Net::VNC.open("#{host}:#{display}",{:wait => 0.001})
+        sequence.each { |s|
+          counter=counter+1
+
+          ui.info "Typing:[#{counter}]: "+s
+
+          keycodes=string_to_vnccode(s)
+
+            keycodes.each do |keycode|
+              if keycode==:wait
+                sleep 1
+              else
+                send_vnc_keycode(vnc,keycode)
+              end
+            end
+        }
+        vnc.close
+        ui.info "Done typing."
+        ui.info ""
+
+      end
+
+      def send_vnc_keycode(vnc,keycode)
+
+        if keycode.is_a?(Symbol)
+          vnc.key_press keycode
+          sleep 1
+        else
+            vnc.type_string keycode,{:wait => 0.1}
+        end
+
+      end
+
+
+      def string_to_vnccode(thestring)
+
+        # http://code.google.com/p/ruby-vnc/source/browse/trunk/data/keys.yaml
+
+        special=Hash.new
+        # Specific veewee
+        special['<Wait>'] = :wait
+
+        # VNC Codes
+        special['<Enter>'] = :return
+        special['<Return>'] =  :return
+        special['<Esc>'] = :escape
+
+        # These still need some work!
+        special['<Backspace>'] = :backspace
+        special['<Spacebar>'] = ' '
+        special['<Tab>'] = :tab
+        # Hmm, what would the equivalent be here
+        special['<KillX>'] = '1d 38 0e';
+
+        special['<Up>'] = :up
+        special['<Down>'] = :down
+        special['<PageUp>'] = :page_up
+        special['<PageDown>'] = :page_down
+        special['<End>'] = :end
+        special['<Insert>'] = :insert
+        special['<Delete>'] = :delete
+        special['<Left>'] = :left
+        special['<Right>'] = :right
+        special['<Home>'] = :home
+
+        special['<F1>'] = :f1
+        special['<F2>'] = :f2
+        special['<F3>'] = :f3
+        special['<F4>'] = :f4
+        special['<F5>'] = :f5
+        special['<F6>'] = :f6
+        special['<F7>'] = :f7
+        special['<F8>'] = :f8
+        special['<F9>'] = :f9
+        special['<F10>'] = :f10
+
+        keycodes=Array.new
+        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<<special[key];
+              thestring=thestring.slice(key.length,thestring.length-key.length)
+              nospecial=false;
+              break;
+            end
+          }
+          if nospecial
+            code = thestring.slice(0,1)
+            keycodes << code
+            #pop one
+            thestring=thestring.slice(1,thestring.length-1)
+          end
+        end
+
+        return keycodes
+      end
+
+
+        end #Module
+      end #Module
+    end #Module
+end #Module
+

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

@@ -0,0 +1,120 @@
+require 'veewee/provider/core/helper/winrm'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def wincp(localfile,remotefile,options={})
+          raise Veewee::Error,"Box is not running" unless self.running?
+
+          if self.exec("cmd.exe /C dir #{wget_vbs_file} > %TEMP%\\null",{:exitcode=>"*"}).status != 0
+            env.ui.warn "Creating wget.vbs"
+            create_wget_vbs_command do |command_chunk, chunk_num|
+              self.exec("cmd.exe /C echo \"Rendering '#{wget_vbs_file}' chunk #{chunk_num}\" && #{command_chunk}")
+            end
+          end
+
+          
+          # Calculate an available kickstart port which we will use for wincp
+          definition.kickstart_port = "7000" if definition.kickstart_port.nil?
+          guessed_port=guess_free_port(definition.kickstart_port.to_i,7199).to_s
+          if guessed_port.to_s!=definition.kickstart_port
+            env.ui.warn "Changing wincp port from #{definition.kickstart_port} to #{guessed_port}"
+            definition.kickstart_port=guessed_port.to_s
+          end
+
+          env.ui.warn "Spinning up a wait_for_http_request on http://#{host_ip_as_seen_by_guest}:#{definition.kickstart_port}#{localfile}"
+          webthread=allow_for_http_request(localfile,{
+              :port => definition.kickstart_port,
+              :host => definition.kickstart_ip,
+              :timeout => definition.kickstart_timeout,
+              :web_dir => '/'
+            })
+          
+          begin
+            self.when_winrm_login_works(self.ip_address,winrm_options.merge(options)) do
+              env.ui.info "Going to try and copy #{localfile} to #{remotefile.inspect}"
+              self.exec("cmd.exe /C cscript %TEMP%\\wget.vbs /url:http://#{host_ip_as_seen_by_guest}:#{definition.kickstart_port}#{localfile} /path:#{remotefile}")
+              # while true do
+              #   sleep 0.1 # used to debug
+              # end
+            end
+          end
+        end
+
+
+        def wget_vbs_file
+          "%TEMP%\\\\wget.vbs"
+        end
+
+        def create_wget_vbs_command(&block)
+          bootstrap_bat = []
+          chunk_num = 0
+          wget_vbs.each_line do |line|
+            # escape WIN BATCH special chars
+            line.gsub!(/[(<|>)^]/).each{|m| "^#{m}"}
+            # windows commands are limited to 2047 characters
+            if((bootstrap_bat + [line]).join(" && ").size > 2047 )
+              yield bootstrap_bat.join(" && "), chunk_num += 1
+              bootstrap_bat = []
+            end
+            bootstrap_bat << ">> #{wget_vbs_file} (echo.#{line.chomp.strip})"
+          end
+          yield bootstrap_bat.join(" && "), chunk_num += 1
+          bootstrap_bat = []
+        end
+
+        def wget_vbs
+          wget_vbs = <<-WGET
+url = WScript.Arguments.Named("url")
+path = WScript.Arguments.Named("path")
+Set objXMLHTTP = CreateObject("MSXML2.ServerXMLHTTP")
+Set wshShell = CreateObject( "WScript.Shell" )
+Set objUserVariables = wshShell.Environment("USER")
+
+'http proxy is optional
+'attempt to read from HTTP_PROXY env var first
+On Error Resume Next
+
+If NOT (objUserVariables("HTTP_PROXY") = "") Then
+objXMLHTTP.setProxy 2, objUserVariables("HTTP_PROXY")
+
+'fall back to named arg
+ElseIf NOT (WScript.Arguments.Named("proxy") = "") Then
+objXMLHTTP.setProxy 2, WScript.Arguments.Named("proxy")
+End If
+
+On Error Goto 0
+
+objXMLHTTP.open "GET", url, false
+objXMLHTTP.send()
+If objXMLHTTP.Status = 200 Then
+Set objADOStream = CreateObject("ADODB.Stream")
+objADOStream.Open
+objADOStream.Type = 1
+objADOStream.Write objXMLHTTP.ResponseBody
+objADOStream.Position = 0
+Set objFSO = Createobject("Scripting.FileSystemObject")
+If objFSO.Fileexists(path) Then objFSO.DeleteFile path
+Set objFSO = Nothing
+objADOStream.SaveToFile path
+objADOStream.Close
+Set objADOStream = Nothing
+End if
+Set objXMLHTTP = Nothing
+WGET
+          #escape_and_echo(win_wget)
+          wget_vbs
+        end
+
+        # escape WIN BATCH special chars
+        # and prefixes each line with an
+        # echo
+        def escape_and_echo(file_contents)
+          file_contents.gsub(/^(.*)$/, 'echo.\1').gsub(/([(<|>)^])/, '^\1')
+        end
+
+      end # Module
+    end # Module
+  end # Module
+end # Module