veewee-atlassian 0.3.11

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

@@ -0,0 +1,102 @@
+require 'socket'
+require 'timeout'
+
+module Veewee
+  module Provider
+    module Core
+      module Helper
+        module Tcp
+
+          def is_tcp_port_open?(ip, port)
+            begin
+              Timeout::timeout(1) do
+                begin
+                  s = TCPSocket.new(ip, port)
+                  s.close
+                  return true
+                rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH,Errno::ENETDOWN
+                  return false
+                end
+              end
+            rescue Timeout::Error
+            end
+
+            return false
+          end
+
+          # This tries to guess a local free tcp port 
+          def guess_free_port(min_port,max_port)
+            ui.info "Received port hint - #{min_port}"
+
+            if definition.force_ssh_port
+              return min_port
+            end
+
+            guessed_port=nil
+
+            for port in (min_port..max_port)
+              unless is_tcp_port_open?(get_local_ip, port)
+                guessed_port=port
+                break
+              end
+            end
+
+            if guessed_port.nil?
+              ui.error "No free port available: tried #{min_port}..#{max_port}"
+              raise Veewee::Error, "No free port available: tried #{min_port}..#{max_port}"
+            else
+              ui.info "Found port #{guessed_port} available"
+            end
+
+            return guessed_port
+          end
+
+          def execute_when_tcp_available(ip="127.0.0.1", options = { } , &block)
+
+            defaults={ :port => 22, :timeout => 2 , :pollrate => 5}
+
+            options=defaults.merge(options)
+            timeout=options[:timeout]
+            timeout=ENV['VEEWEE_TIMEOUT'].to_i unless ENV['VEEWEE_TIMEOUT'].nil?
+
+            begin
+              Timeout::timeout(timeout) do
+                connected=false
+                while !connected do
+                  begin
+                    ui.info "trying connection"
+                    s = TCPSocket.new(ip, options[:port])
+                    s.close
+                    block.call(ip);
+                    return true
+                  rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH,Errno::ENETDOWN
+                    sleep options[:pollrate]
+                  end
+                end
+              end
+            rescue Timeout::Error
+              raise "Timeout connecting to TCP port {options[:port]} exceeded #{timeout} secs."
+            end
+
+            return false
+          end
+
+          def host_ip_as_seen_by_guest
+            get_local_ip
+          end
+
+          def get_local_ip
+            orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+
+            UDPSocket.open do |s|
+              s.connect '64.233.187.99', 1
+              s.addr.last
+            end
+          ensure
+            Socket.do_not_reverse_lookup = orig
+          end
+        end #Module
+      end #Module
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,83 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+        require 'webrick'
+        include WEBrick
+        module Servlet
+
+
+          class FileServlet < WEBrick::HTTPServlet::AbstractServlet
+
+            attr_reader :ui, :threaded
+
+            def initialize(server,localfile,ui,threaded)
+              super(server)
+              @server=server
+              @localfile=localfile
+              @ui=ui
+              @threaded=threaded
+            end
+
+            def do_GET(request,response)
+              response['Content-Type']='text/plain'
+              response.status = 200
+              content = File.open(@localfile, "r").read
+              response.body = case File.extname(@localfile)
+              when ".erb"
+                ui.info "Rendering and serving file #{@localfile}"
+                ERB.new(content).result(binding)
+              else
+                ui.info "Serving file #{@localfile}"
+                content
+              end
+              if not @threaded
+                ui.info "Shutting down for #{@localfile}"
+                @server.shutdown
+              end
+            end
+          end
+
+        end
+        module Web
+
+          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:'
+
+            webrick_logger=WEBrick::Log.new(fn, WEBrick::Log::INFO)
+
+            web_dir=options[:web_dir]
+            filename=filename
+            s= ::WEBrick::HTTPServer.new(
+              :Port => options[:port],
+              :Logger => webrick_logger,
+              :AccessLog => webrick_logger
+            )
+            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
+          end
+
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module

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/core/provider.rb

@@ -0,0 +1,85 @@
+require 'veewee/provider/core/helper/shell'
+module Veewee
+  module Provider
+    module Core
+      class Provider
+
+        attr_accessor :env
+        attr_accessor :options
+
+        attr_accessor :type
+        attr_accessor :name
+
+        include ::Veewee::Provider::Core::Helper::Shell
+
+        def ui
+          return @_ui if defined?(@_ui)
+          @_ui = @env.ui.dup
+          @_ui.resource = @name
+          @_ui
+        end
+
+        def initialize(name,options,env)
+
+          @env=env
+          @name=name
+          @options=options
+          @type=self.class.to_s.split("::")[-2]
+          check_requirements
+        end
+
+        def get_box(name)
+          begin
+            require_path='veewee/provider/'+type.to_s.downcase+"/box.rb"
+            require require_path
+
+            # Get a real box object from the Provider
+            box=Object.const_get("Veewee").const_get("Provider").const_get(type.to_s.capitalize).const_get("Box").new(name,env)
+
+            # Attach the provider to the box
+            box.provider = self
+
+            return box
+          rescue Error => ex
+            ui.error "Could not instante the box #{name} with provider #{type} ,#{ex}"
+            raise
+          end
+        end
+
+        def self.available?
+          begin
+            self.check_requirements
+            return true
+          rescue Error
+            return false
+          end
+        end
+
+        def gem_available?(gemname)
+          env.logger.info "Checking for gem #{gemname}"
+          available=false
+          begin
+            available=true unless Gem::Specification::find_by_name("#{gemname}").nil?
+          rescue Gem::LoadError
+            env.logger.info "Error loading gem #{gemname}"
+            available=false
+          rescue
+            env.logger.info "Falling back to old syntax for #{gemname}"
+            available=Gem.available?("#{gemname}")
+            env.logger.info "Old syntax #{gemname}.available? #{available}"
+          end
+          return available
+        end
+
+        def gems_available?(names)
+          names.each do |gemname|
+            return false if !gem_available?(gemname)
+          end
+          return true
+        end
+
+      end #End Class
+
+    end #End Module
+  end #End Module
+end #End Module

data/lib/veewee/provider/core/provider/transaction.rb

@@ -0,0 +1,25 @@
+##Note: this is currently not used anymore, it seems no one is using it
+
+module Veewee
+  class Transaction
+
+  def transaction(name,params, &block)
+  end
+
+  def transaction2(name,options= { :checksum => "nochecksum"}, &block)
+     if snapshot_exists(@vmname,name+"-"+options[:checksum])
+        load_snapshot_vmachine(@vmname,name+"-"+options[:checksum])
+      else
+        if snapshot_version_exists(@vmname,name)
+          rollback_snapshot(@vmname,name)
+          #rollback to snapshot prior to this one
+        end
+        yield
+        create_snapshot_vmachine(@vmname,name+"-"+options[:checksum])
+      end
+    #end
+  end
+
+
+end
+end