veewee 0.2.3 → 0.3.0.alpha1

data/lib/veewee/shell.rb

@@ -1,54 +0,0 @@
-#require 'open4'
-
-module Veewee
-  class Shell
- 
-    def self.execute2(command,options = {})
-
-      IO.popen("#{command}") { |f| print f }
-    end
-    
-    #pty allows you to gradually see the output of a local command
-    #http://www.shanison.com/?p=415
-      def self.execute(command, options = {} )
-        require "pty"
-            begin
-              PTY.spawn( command ) do |r, w, pid|
-                begin
-                  r.each { }      
-                  #r.each { |line| print line;}      
-
-               rescue Errno::EIO        
-               end      
-             end  
-           rescue PTY::ChildExited => e
-              puts "The child process exited!"
-           end
-      end
-
-      #occassinally fails with 'no child processes
-      def self.execute3(command, options = {} )
-        defaults= { :port => "22", :exitcode => "0", :user => "root"}
-          options=defaults.merge(options) 
-
-          status = POpen4::popen4(command) do |stdout,stderr,stdin|
-            stdout.each do |line|
-              puts line
-            end
-          end
-          
-        @status=status.to_i
-  
-        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
-
-      end
-
-  end #Class
-end #Module

data/lib/veewee/ssh.rb

@@ -1,193 +0,0 @@
-module Veewee
-  class Ssh
-
-    def self.when_ssh_login_works(ip="localhost", options = {  } , &block)
-
-      defaults={ :port => '22', :timeout => 200 , :user => 'vagrant', :password => 'vagrant'}
-
-      options=defaults.merge(options)
-
-      puts
-      puts "Waiting for ssh login with user #{options[:user]} to sshd on port => #{options[:port]} to work"
-
-      begin
-        Timeout::timeout(options[:timeout]) do
-          connected=false
-          @key_auth_tried = false
-          ssh_options = { :port => options[:port] , :password => options[:password], :paranoid => false, :timeout => options[:timeout]  }
-          while !connected do
-            begin
-              print "."
-              Net::SSH.start(ip, options[:user], ssh_options) do |ssh|
-                block.call(ip);
-                puts ""
-                return true
-              end
-            rescue Net::SSH::AuthenticationFailed
-              options[:keys] = File.join(File.dirname(__FILE__),'./../../validation/vagrant')
-              options.delete(:password)
-              ssh_options = options
-              if @key_auth_tried
-                 raise
-              else
-                 @key_auth_tried = true
-                retry
-              end
-            rescue Net::SSH::Disconnect,Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ENETUNREACH
-              sleep 5
-            end
-          end
-        end
-      rescue Timeout::Error
-        raise 'ssh timeout'
-      end
-      puts ""
-      return false
-    end
-
-
-    def self.transfer_file(host,filename,destination = '.' , options = {})
-      
-      Net::SSH.start( host,options[:user],options ) do |ssh|
-        puts "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}%"
-          print "."
-
-        end
-      end 
-      puts
-    end
-
-
-    #we need to try the actual login because vbox gives us a connect
-    #after the machine boots
-    def self.execute_when_tcp_available(ip="localhost", 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
-              puts "trying connection"
-              s = TCPSocket.new(ip, options[:port])
-              s.close
-              block.call(ip);
-              return true
-            rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-              sleep options[:pollrate]
-            end
-          end
-        end
-      rescue Timeout::Error
-        raise 'timeout connecting to port'
-      end
-
-      return false
-    end
-
-    def self.execute(host,command, options = { :progress => "on"} )
-      defaults= { :port => "22", :exitcode => "0", :user => "root"}
-      options=defaults.merge(options)
-      @pid=""
-      @stdin=command
-      @stdout=""
-      @stderr=""
-      @status=-99999
-
-      puts "Executing command: #{command}"
-
-      @key_auth_tried = false
-      ssh_options = { :port => options[:port], :password => options[:password], :paranoid => false}
-      # ssh_options[:verbose] => :debug
-      begin
-        Net::SSH.start(host, options[:user], ssh_options) 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
-
-                    print data
-
-                end
-
-                # "on_extended_data" is called when the process writes something to stderr
-                ch.on_extended_data do |c, type, data|
-                  @stderr+=data
-
-                    print 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
-                    puts "ERROR: exit code #{exit_code}"
-                  else
-                    #puts "Successfully executed"
-                  end
-                end
-
-                channel.on_request("exit-signal") do |ch, data|
-                  puts "SIGNAL: #{data.read_long}"
-                end
-
-                ch.on_close {
-                  #puts "done!"
-                }
-                #status=ch.exec "echo $?"
-              end
-            end
-            channel.wait
-          end
-      rescue Net::SSH::AuthenticationFailed
-        ssh_options[:keys] = Array.new([File.join(File.dirname(__FILE__),'./../../validation/vagrant')])
-        ssh_options.delete(:password)
-        ssh_options[:auth_methods] = ['publickey']
-        if @key_auth_tried
-           raise
-        else
-           @key_auth_tried = true
-          retry
-        end
-      rescue Net::SSH::Disconnect, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ENETUNREACH
-        sleep 1
-      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
-
-    end
-
-
-
-  end #Class
-end #Module

data/lib/veewee/transaction.rb

@@ -1,122 +0,0 @@
-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
-
-  def self.remove_snapshot_vmachine(vmname,snapname)
-    @vboxcmd=Veewee::Session.determine_vboxcmd
-    
-    Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' delete '#{snapname}'")
-  end
-
-  def self.create_snapshot_vmachine(vmname,snapname)
-    @vboxcmd=Veewee::Session.determine_vboxcmd
-    
-    Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' take '#{snapname}'")
-  end
-
-  def self.load_snapshot_vmachine(vmname,snapname)
-    @vboxcmd=Veewee::Session.determine_vboxcmd
-    
-    #if it running , shutdown first
-    if (state_vmachine(vmname)=="running")
-      stop_vmachine(vmname)
-    end
-
-    Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' restore '#{snapname}'")
-    #sometimes it takes some time to shutdown
-    sleep 2
-    Veewee::Shell.execute("#{@vboxcmd} startvm '#{vmname}'")
-  end
-
-  def self.snapshot_exists(vmname,snapname)
-    list_snapshots(vmname).each { |name|
-      if (name==snapname) then
-        return true
-      end
-    }
-    return false
-  end
-
-  def self.snapshot_version_exists(vmname,snapname)
-        list_snapshots(vmname).each { |name|
-          if name.match(/^#{snapname}-/) then
-            return true
-          end
-        }
-        return false
-  end
-
-  def self.rollback_snapshot(vmname,snapname)
-    delete_flag=false
-    @vboxcmd=Veewee::Session.determine_vboxcmd
-
-    savestate_recover=false
-    if (state_vmachine(vmname)=="running")
-      Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' savestate")
-      savestate_recover=true
-     end
-
-    list_snapshots(vmname).each { |name|
-      if name.match(/^#{snapname}-/) then
-        delete_flag=true
-      end
-      if (delete_flag) then
-        remove_snapshot_vmachine(vmname,name)
-        sleep 1
-      end
-    }
-    
-    
-     sleep 2
-
-      Veewee::Shell.execute("#{@vboxcmd} startvm '#{vmname}'")
-
-      if (savestate_recover)
-        #Recovering from savestate nukes the network! This trick seem to work
-        #Also within the vm /etc/init.d/networking restart , but that is OS specific
-        #http://www.virtualbox.org/ticket/5666
-        #http://www.virtualbox.org/ticket/5654
-        #This is supposed to be fixed: http://www.virtualbox.org/changeset/25205 but alas
-        Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' nic1 nat")
-        Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' setlinkstate1 off")
-        Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' setlinkstate1 on")
-        sleep 2
-
-        #hmmm, virtualbox => when recovering from a restore , it looses the nat settings!!! So we need to do this again!!
-        #thebox.ssh_enable_vmachine({:hostport => host_port , :guestport => 22} )
-        #http://www.virtualbox.org/changeset/25402
-        #[25402]: NAT: re-establish port-forwarding after savestate / restore state
-
-      end
-
-    end
-
-
-    def self.list_snapshots(vmname)
-      @vboxcmd=Veewee::Session.determine_vboxcmd
-      
-      snapshotresult=Veewee::Shell.execute("#{@vboxcmd} showvminfo --machinereadable '#{vmname}' |grep ^SnapshotName| cut -d '=' -f 2").stdout
-      snapshotlist=snapshotresult.gsub(/\"/,'').split(/\n/)
-      return snapshotlist
-    end
-
-end
-end
-
-    

data/lib/veewee/utils.rb

@@ -1,26 +0,0 @@
-require 'socket'
-require 'timeout'
-
-module Veewee
-  class Utils
-
-    def self.is_port_open?(ip, port)
-      begin
-        Timeout::timeout(1) do
-          begin
-            s = TCPSocket.new(ip, port)
-            s.close
-            return true
-          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            return false
-          end
-        end
-		  rescue Timeout::Error
-	    end
-
-	    return false
-	end
-
-
-  end #Class
-end #Module

data/lib/veewee/web.rb

@@ -1,48 +0,0 @@
-module Veewee
-  class Web
-
-    require 'webrick'
-    include WEBrick
-
-    class FileServlet < WEBrick::HTTPServlet::AbstractServlet
-             
-              def initialize(server,localfile)
-                super(server)
-                @server=server
-                @localfile=localfile
-              end
-             def do_GET(request,response)
-                     response['Content-Type']='text/plain'
-                     response.status = 200
-                     puts "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 
-
-    def self.wait_for_request(filename,options={:timeout => 10, :web_dir => "", :port => 7125})  
-      
-      webrick_logger=WEBrick::Log.new("/dev/null", WEBrick::Log::INFO)
-      
-      web_dir=options[:web_dir]
-      filename=filename
-      s= HTTPServer.new(
-        :Port => options[:port],
-        :Logger => webrick_logger,
-        :AccessLog => webrick_logger
-      )
-      s.mount("/#{filename}", FileServlet,File.join(web_dir,filename))
-      trap("INT"){
-          s.shutdown
-          puts "Stopping webserver"
-          exit
-        }
-      s.start
-    end
-    
-  end
-end

data/templates/CentOS-6.1-x86_64-minimal/definition.rb

@@ -1,15 +0,0 @@
-Veewee::Session.declare({
-  :cpu_count => '1', :memory_size=> '512',
-  :disk_size => '10140', :disk_format => 'VDI', :hostiocache => 'off',
-  :os_type_id => 'RedHat_64',
-  :iso_file => "CentOS-6.1-x86_64-minimal.iso", :iso_src => "http://mirror.internode.on.net/pub/centos/6.1/isos/x86_64/CentOS-6.1-x86_64-minimal.iso", :iso_md5 => "03177dfefb4ebfeb03f457c29f00b0a1", :iso_download_timeout => 1000,
-  :boot_wait => "10", :boot_cmd_sequence => [
-    '<Tab> text ks=http://%IP%:%PORT%/ks.cfg<Enter>'
-  ],
-  :kickstart_port => "7122", :kickstart_timeout => 10000, :kickstart_file => "ks.cfg",
-  :ssh_login_timeout => "100", :ssh_user => "vagrant", :ssh_password => "vagrant", :ssh_key => "",
-  :ssh_host_port => "7222", :ssh_guest_port => "22",
-  :sudo_cmd => "echo '%p'|sudo -S sh '%f'",
-  :shutdown_cmd => "/sbin/halt -h -p",
-  :postinstall_files => [ "postinstall.sh"], :postinstall_timeout => 10000
-})