vbox 0.0.4

data/lib/vbox/shell.rb

@@ -0,0 +1,54 @@
+#require 'open4'
+
+module Vbox
+  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/vbox/ssh.rb

@@ -0,0 +1,193 @@
+module Vbox
+  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/vbox/transaction.rb

@@ -0,0 +1,122 @@
+module Vbox
+  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=Vbox::Session.determine_vboxcmd
+
+      Vbox::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' delete '#{snapname}'")
+    end
+
+    def self.create_snapshot_vmachine(vmname,snapname)
+      @vboxcmd=Vbox::Session.determine_vboxcmd
+
+      Vbox::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' take '#{snapname}'")
+    end
+
+    def self.load_snapshot_vmachine(vmname,snapname)
+      @vboxcmd=Vbox::Session.determine_vboxcmd
+
+      #if it running , shutdown first
+      if (state_vmachine(vmname)=="running")
+        stop_vmachine(vmname)
+      end
+
+      Vbox::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' restore '#{snapname}'")
+      #sometimes it takes some time to shutdown
+      sleep 2
+      Vbox::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=Vbox::Session.determine_vboxcmd
+
+      savestate_recover=false
+      if (state_vmachine(vmname)=="running")
+        Vbox::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
+
+      Vbox::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
+        Vbox::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' nic1 nat")
+        Vbox::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' setlinkstate1 off")
+        Vbox::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=Vbox::Session.determine_vboxcmd
+
+      snapshotresult=Vbox::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/vbox/utils.rb

@@ -0,0 +1,26 @@
+require 'socket'
+require 'timeout'
+
+module Vbox
+  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/vbox/version.rb

@@ -0,0 +1,3 @@
+module Vbox
+  VERSION = "0.0.4"
+end

data/lib/vbox/web.rb

@@ -0,0 +1,48 @@
+module Vbox
+  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