veewee 0.3.0.alpha4 → 0.3.0.alpha5

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

@@ -0,0 +1,162 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+
+        class SshResult
+          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)
+
+            env.ui.info  "Waiting for ssh login on #{ip} with user #{options[:user]} to sshd on port => #{options[:port]} to work, timeout=#{options[:timeout]} sec"
+
+            begin
+              Timeout::timeout(options[:timeout]) do
+                connected=false
+                while !connected do
+                  begin
+                    env.ui.info ".",{:new_line => false}
+                    Net::SSH.start(ip, options[:user], { :port => options[:port] , :password => options[:password], :paranoid => false , :timeout => options[:timeout] }) do |ssh|
+                      env.ui.info "\n"
+
+                      block.call(ip);
+                      env.ui.info ""
+                      return true
+                    end
+                  rescue Net::SSH::Disconnect,Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ENETUNREACH,Errno::ETIMEDOUT, Errno::ENETUNREACH
+                    sleep 5
+                  end
+                end
+              end
+            rescue Timeout::Error
+              env.ui.error "Ssh timeout #{options[:timeout]} sec has been reached."
+              exit -1
+            end
+            env.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|
+              env.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}
+
+              end
+            end
+            env.ui.info ""
+          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
+
+            env.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
+
+                    env.ui.info data,{:new_line => false}
+
+                  end
+
+                  # "on_extended_data" is called when the process writes something to stderr
+                  ch.on_extended_data do |c, type, data|
+                    stderr+=data
+
+                    env.ui.info data,{:new_line => false}
+
+                  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
+                      env.ui.info "ERROR: exit code #{exit_code}"
+                    else
+                      #env.ui.info "Successfully executed"
+                    end
+                  end
+
+                  channel.on_request("exit-signal") do |ch, data|
+                    env.ui.info "SIGNAL: #{data.read_long}"
+                  end
+
+                  ch.on_close {
+                    #env.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 "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

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

@@ -0,0 +1,96 @@
+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)
+            env.ui.info "Received port hint - #{min_port}"
+
+            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?
+              env.ui.info "No free port available: tried #{min_port}..#{max_port}"
+              exit -1
+            else
+              env.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)
+
+            begin
+              Timeout::timeout(options[:timeout]) do
+                connected=false
+                while !connected do
+                  begin
+                    env.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 port'
+            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,67 @@
+module Veewee
+  module Provider
+    module Core
+      module Helper
+        require 'webrick'
+        include WEBrick
+        module Servlet
+
+
+          class FileServlet < WEBrick::HTTPServlet::AbstractServlet
+
+            attr_reader :env
+
+            def initialize(server,localfile,env)
+              super(server)
+              @server=server
+              @localfile=localfile
+              @env=env
+            end
+
+            def do_GET(request,response)
+              response['Content-Type']='text/plain'
+              response.status = 200
+              env.ui.info "Serving file #{@localfile}"
+              displayfile=File.open(@localfile,'r')
+              content=displayfile.read()
+              response.body=content
+              #If we shut too fast it might not get the complete file
+              sleep 2
+              @server.shutdown
+            end
+          end
+
+        end
+        module Web
+
+          def wait_for_http_request(filename,options={:timeout => 10, :web_dir => "", :port => 7125})
+
+
+            # 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
+            )
+            env.logger.debug("mounting file /#{filename}")
+            s.mount("/#{filename}", Veewee::Provider::Core::Helper::Servlet::FileServlet,File.join(web_dir,filename),env)
+            trap("INT"){
+              s.shutdown
+              env.ui.info "Stopping webserver"
+              exit
+            }
+            s.start
+          end
+
+        end #Class
+      end #Module
+    end #Module
+  end #Module
+end #Module

data/lib/veewee/{builder/core/builder.rb → provider/core/provider.rb}

@@ -1,16 +1,8 @@
-require 'veewee/util/tcp'
-require 'veewee/util/web'
-require 'veewee/util/ssh'
-require 'veewee/util/shell'
-
-
-require 'veewee/builder/core/builder/build.rb'
-require 'veewee/builder/core/builder/iso.rb'
-
+require 'veewee/provider/core/helper/shell'
 module Veewee
-  module Builder
+  module Provider
     module Core
-      class Builder
+      class Provider
 
         attr_accessor :env
         attr_accessor :options
@@ -18,11 +10,7 @@ module Veewee
         attr_accessor :type
         attr_accessor :name
 
-        include ::Veewee::Builder::Core::BuilderCommand
-        include ::Veewee::Util::Tcp
-        include ::Veewee::Util::Web
-        include ::Veewee::Util::Ssh
-        include ::Veewee::Util::Shell
+        include ::Veewee::Provider::Core::Helper::Shell
 
         def initialize(name,options,env)
 
@@ -33,21 +21,16 @@ module Veewee
           check_requirements
         end
 
-        def get_definition(name)
-          env.logger.info("fetching definition #{name}")
-          definition=env.get_definition(name)
-          return definition
-        end
-
         def get_box(name)
           begin
-            require_path='veewee/builder/'+type.to_s.downcase+"/box.rb"
+            require_path='veewee/provider/'+type.to_s.downcase+"/box.rb"
             require require_path
 
-            # Get a real box object from the builder
-            box=Object.const_get("Veewee").const_get("Builder").const_get(type.to_s.capitalize).const_get("Box").new(name,env)
+            # 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)
           rescue Error => ex
             env.ui.error "Could not instante the box #{name} with provider #{type} ,#{ex}"
+            raise
           end
         end
 

data/lib/veewee/{builder/core/builder → provider/core/provider}/tunnel.rb

@@ -1,9 +1,9 @@
 #require 'net/ssh/multi'
 
 module Veewee
-  module Builder
+  module Provider
     module Core
-      module BuilderCommand
+      module ProviderCommand
 
 
       def ssh_tunnel_start(forwardings)

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

@@ -0,0 +1,46 @@
+require 'veewee/provider/core/box'
+require 'veewee/provider/core/box/vnc'
+require 'veewee/provider/kvm/box/validate_kvm'
+
+require 'veewee/provider/kvm/box/build'
+require 'veewee/provider/kvm/box/create'
+require 'veewee/provider/kvm/box/up'
+require 'veewee/provider/kvm/box/halt'
+require 'veewee/provider/kvm/box/poweroff'
+require 'veewee/provider/kvm/box/destroy'
+
+require 'veewee/provider/kvm/box/helper/ip'
+require 'veewee/provider/kvm/box/helper/ssh_options'
+require 'veewee/provider/kvm/box/helper/status'
+require 'veewee/provider/kvm/box/helper/console_type'
+
+module Veewee
+  module Provider
+    module Kvm
+      class Box < Veewee::Provider::Core::Box
+
+        include ::Veewee::Provider::Core
+        include ::Veewee::Provider::Kvm
+
+        include ::Veewee::Provider::Core::BoxCommand
+        include ::Veewee::Provider::Kvm::BoxCommand
+
+        attr_accessor :connection
+
+        def initialize(name,env)
+
+          require 'libvirt'
+          require 'fog'
+
+          super(name,env)
+
+          @connection=::Fog::Compute.new(:provider => "Libvirt",
+                                         :libvirt_uri => "qemu:///system",
+                                         :libvirt_ip_command => "arp -an |grep $mac|cut -d '(' -f 2 | cut -d ')' -f 1")
+
+        end
+
+      end # End Class
+    end # End Module
+  end # End Module
+end # End Module

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

@@ -0,0 +1,11 @@
+module Veewee
+  module Provider
+    module Kvm
+      module BoxCommand
+        def build(options)
+          super(options)
+        end
+      end
+    end # End Module
+  end # End Module
+end # End Module