oats 0.0.1

data/lib/oats/oselenium.rb

@@ -0,0 +1,189 @@
+require 'oats/oats_selenium_api'
+
+# Advertised OATS methods to be used from tests
+# Selenium object accessor created on demand by Oat.browser
+
+def selenium
+  $selenium || Oats.browser
+end
+
+module Oats
+
+  class Oselenium
+    @@browsers = []
+    attr_reader :browser, :site, :login_base_url, :user
+    @@server_started_by_oats = false
+
+    def Oselenium.browsers
+      @@browsers
+    end
+
+    def Oselenium.browser(*args)
+      if args.include?(true)
+        new_browser = true
+        args.delete true
+      end
+      if not args.empty?
+        if not new_browser and Oselenium.browsers.last
+          return Oselenium.browsers.last.login(*args)
+        else
+          return Oselenium.new(*args).browser
+        end
+      elsif Oselenium.browsers.last
+        return Oselenium.browsers.last
+      else
+        return Oselenium.new.browser
+      end
+    end
+
+    def initialize(*args)
+
+      browser_type = $oats['selenium']['browser_type']
+      #    is_webdriver = ! $oats['selenium']['rcdriver']
+
+      unless $oats_global['download_dir']
+        if browser_type == 'firefox'
+          $oats_global['download_dir'] = $oats['execution']['dir_results'] + '/downloads'
+        elsif Oats.data("selenium.default_downloads")
+          $oats_global['download_dir'] = File.join(ENV[ ENV['OS'] == 'Windows_NT' ? 'USERPROFILE' : 'HOME'], 'Downloads')
+          $oats_global['download_dir'].gsub!('\\','/') if ENV['OS'] == 'Windows_NT'
+        end
+      end
+
+      download_dir = $oats_global['download_dir'].gsub('/','\\\\') if $oats_global['download_dir'] and
+        ENV['OS'] == 'Windows_NT'
+      download_dir ||= $oats_global['download_dir']
+      case browser_type
+      when 'firefox'
+        profile = $oats['selenium']['firefox_profile']
+        $oats_global["browser_path"] ||= ENV[profile] if profile
+        #      if is_webdriver
+        profile = Selenium::WebDriver::Firefox::Profile.from_name profile if profile
+        profile = Selenium::WebDriver::Firefox::Profile.new unless profile
+        profile['browser.download.dir'] = download_dir
+        profile["browser.helperApps.neverAsk.saveToDisk"] = "text/plain, application/vnd.ms-excel, application/pdf, text/csv"
+        profile['browser.download.folderList'] = 2
+        $oats['selenium']['firefox_profile_set'].each { |method,value| profile.send method+'=', value }
+
+      when 'chrome'
+        profile = Selenium::WebDriver::Chrome::Profile.new
+        profile['download.prompt_for_download'] = false
+        profile['download.default_directory'] = download_dir
+        unless $oats_global['browser_path']
+          vpath = File.join($oats['_']['vendor'], ENV['OS'], 'chromedriver' + (ENV['OS'] == 'Windows_NT' ? '.exe' : '') )
+          $oats_global['browser_path'] = vpath if File.exist?(vpath)
+        end
+      end
+      FileUtils.rm_f Dir.glob(File.join($oats_global['download_dir'],'*')) if $oats_global['download_dir']
+      Oats.info "Browser type: #{browser_type.inspect}, profile: #{profile.inspect}, path: #{$oats_global["browser_path"].inspect}"
+      $oats_info['browser'] = $oats['selenium']['browser_type'].sub(/ .*/,'')
+      remote_webdriver = $oats['selenium']['remote_webdriver']
+      driver_type = $oats['selenium']['browser_type']
+      if remote_webdriver
+        remote_webdriver = remote_webdriver[browser_type]
+        if remote_webdriver
+          driver_type = 'remote'
+          @remote_webdriver_is_active = true
+        end
+      end
+      opts = [ driver_type.to_sym ]
+      opts_hash ={}
+      opts_hash[:profile] = profile if profile and driver_type != 'remote'
+      if driver_type == 'remote'
+        opts_hash[:url] = "http://"+remote_webdriver+'/wd/hub'
+        opts_hash[:desired_capabilities] = $oats['selenium']['browser_type'].to_sym
+      end
+      case browser_type
+      when /firefox/
+        Selenium::WebDriver::Firefox.path = $oats_global["browser_path"]
+      when /chrome/
+        Selenium::WebDriver::Chrome.driver_path = $oats_global['browser_path']
+      end if $oats_global['browser_path']
+      browser_options = Oats.data "selenium.options.#{browser_type}"
+      browser_options.each_pair { |name, val| opts_hash[name.to_sym] = val } if browser_options
+      opts.push(opts_hash) unless opts_hash.empty?
+      #      OatsLock.record_firefox_processes do
+      @browser = Selenium::WebDriver.for(*opts)
+      #      end
+      @browser.osel = self
+      $selenium = @browser
+      @@browsers << @browser
+      login(*args)
+    end
+
+    # Stub method/interface for actions to take after instantiating the browser
+    def login(*args) #
+      selenium.open(args.first)
+    end
+
+    # True if selenium is running in remote_webdriver mode
+    def remote_webdriver?
+      @remote_webdriver_is_active
+    end
+
+    # Fixes the path to Windows if running on windows remote webdriver
+    def Oselenium.remote_webdriver_map_file_path(file)
+      if $selenium and $selenium.osel.remote_webdriver?
+        file.sub!(ENV['OATS_HOME'], $oats['selenium']['remote_webdriver']['oats_dir'])
+        file_os = $oats['selenium']['remote_webdriver']['os']
+      else
+        file_os = ENV['OS']
+      end
+      file_os == 'Windows_NT' ? file.gsub('/','\\') : file
+    end
+
+    def Oselenium.reset
+      Oselenium.close
+    rescue Timeout::Error
+      ## Sometimes doesn't die gracefully. It is OK, will be killed below.
+    ensure
+      @@browsers = []
+      $selenium = nil
+      OatsLock.kill_webdriver_browsers
+    end
+
+    def Oselenium.close
+      while browser = Oselenium.browsers.pop
+        if browser.osel.site
+          browser.oats_debug "Closing browser session from #{browser.osel.site}"
+        else
+          browser.oats_debug "Closing browser session."
+        end
+        browser.quit
+      end
+      $selenium = nil
+    end
+
+    def Oselenium.pause_browser
+      return if Oselenium.browsers.empty? or ! TestData.pause_after_error
+      seconds = 999999
+      pause_val = $oats['selenium']['pause_on_exit']
+      if not pause_val.integer? or
+          pause_val <= 0
+        seconds = nil
+      elsif pause_val == 1
+        seconds = nil unless TestData.current_test.status == 1
+      elsif pause_val > 0
+        seconds = pause_val
+      end
+      if seconds
+        $stderr.puts "Paused because selenium:pause_on_exit is set to [#{pause_val}]"
+        $stderr.puts "PLEASE HIT <ENTER> TO CONTINUE!"
+        begin
+          # timeout(seconds) { loop { browser.get_title ; sleep 1 } }
+          timeout(seconds) { STDIN.readline }
+        rescue Timeout::Error
+        end
+      end
+      TestData.pause_after_error = false
+    end
+
+    def Oselenium.port
+      #    if $oats_execution['agent']
+      #      '4'+$oats_execution['agent']['execution:occ:agent_port'].to_s
+      #    else
+      $oats['selenium']['port']
+      #    end
+    end
+  end
+end

data/lib/oats/ossh.rb

@@ -0,0 +1,36 @@
+#require 'util'
+class OatsOsshMissingInput < OatsTestError ; end
+
+module Oats
+
+  # Implement Oats.rssh and Oats.rput functionality. See Oats.rssh documentation.
+  module Ossh
+    def Ossh.run(cmd_file, dir = nil ,  host = nil, username = nil, rput = nil)
+      username ||= Oats.data['ssh']['username']
+      host ||= Oats.data['ssh']['host']
+      raise(OatsOsshMissingInput, "Ossh plink requires a host.") unless host
+      if username == 'root'
+        cmd = "plink #{host} -l #{Oats.data['ssh']['root_sudo_username']} "
+        cmd_file = 'sudo -u root ' + cmd_file
+      else
+        cmd = "plink #{host} -l #{username} "
+      end
+      if rput
+        source_cmd = 'echo'
+        if File.exist?(cmd_file)
+          cmd_file.gsub! /\//, '\\'
+          source_cmd = 'type'
+        end
+        cmd = "#{source_cmd} #{cmd_file} | #{cmd}\"/home/levent.atasoy/bin/oats_put_file.sh #{dir}\""
+      else
+        if dir
+          cmd += "\"cd #{dir} ; #{cmd_file} 2>&1\""
+        else
+          cmd += "\"#{cmd_file} 2>&1\""
+        end
+      end
+      $log.info cmd
+      `#{cmd}`
+    end
+  end
+end

data/lib/oats/patches_for_eventmachine_12.10.rb

@@ -0,0 +1,66 @@
+module EventMachine
+
+  def self.event_callback conn_binding, opcode, data # :nodoc:
+    #
+    # Changed 27Dec07: Eliminated the hookable error handling.
+    # No one was using it, and it degraded performance significantly.
+    # It's in original_event_callback, which is dead code.
+    #
+    # Changed 25Jul08: Added a partial solution to the problem of exceptions
+    # raised in user-written event-handlers. If such exceptions are not caught,
+    # we must cause the reactor to stop, and then re-raise the exception.
+    # Otherwise, the reactor doesn't stop and it's left on the call stack.
+    # This is partial because we only added it to #unbind, where it's critical
+    # (to keep unbind handlers from being re-entered when a stopping reactor
+    # runs down open connections). It should go on the other calls to user
+    # code, but the performance impact may be too large.
+    #
+    if opcode == ConnectionUnbound
+      if c = @conns.delete( conn_binding )
+        begin
+          c.unbind
+        rescue
+          @wrapped_exception = $!
+          stop
+        end
+      elsif c = @acceptors.delete( conn_binding )
+        # no-op
+      else
+        # raise ConnectionNotBound, "recieved ConnectionUnbound for an unknown signature: #{conn_binding}"
+      end
+    elsif opcode == ConnectionAccepted
+      accep,args,blk = @acceptors[conn_binding]
+      raise NoHandlerForAcceptedConnection unless accep
+      c = accep.new data, *args
+      @conns[data] = c
+      blk and blk.call(c)
+      c # (needed?)
+    elsif opcode == ConnectionCompleted
+      c = @conns[conn_binding]
+      if c
+        c.connection_completed
+        # else
+        # raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
+      end
+      ##
+      # The remaining code is a fallback for the pure ruby and java reactors.
+      # In the C++ reactor, these events are handled in the C event_callback() in rubymain.cpp
+    elsif opcode == TimerFired
+      t = @timers.delete( data )
+      return if t == false # timer cancelled
+      t or raise UnknownTimerFired, "timer data: #{data}"
+      t.call
+    elsif opcode == ConnectionData
+      c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
+      c.receive_data data
+    elsif opcode == LoopbreakSignalled
+      run_deferred_callbacks
+    elsif opcode == ConnectionNotifyReadable
+      c = @conns[conn_binding] or raise ConnectionNotBound
+      c.notify_readable
+    elsif opcode == ConnectionNotifyWritable
+      c = @conns[conn_binding] or raise ConnectionNotBound
+      c.notify_writable
+    end
+  end
+end

data/lib/oats/ragent.rb

@@ -0,0 +1,321 @@
+#require 'eventmachine' # http://eventmachine.rubyforge.org/EventMachine.html#M000486
+#require 'patches_for_eventmachine_12.10'
+require 'em-http-request' # https://github.com/igrigorik/em-http-request/wiki/Issuing-Requests
+require 'json'
+
+module Oats
+
+  class Ragent < EventMachine::Connection
+    attr_accessor :job_count, :jid, :occ_reintroduction_wait_time
+    attr_reader :request
+    @@logger = nil
+    @@oats_info_snapshot = {}
+    @@job_count = 1
+    @@occ_default = nil
+    @@logger = Log4r::Logger.new('A')
+    include EM::P::ObjectProtocol
+
+
+    # Non-nil if in the state of requesting for the next job
+    def Ragent.in_next_job
+      @@in_next_job
+    end
+    def Ragent.in_next_job=(v)
+      @@in_next_job = v
+    end
+    def Ragent.is_busy=(jid)
+      @@is_busy = jid
+    end
+    # Current/Last jobid worked on, or false
+    def Ragent.is_busy
+      @@is_busy
+    end
+
+    # Contains YAML OCC entries if oats is started in agent mode
+    def Ragent.occ
+      @@occ_default
+    end
+
+    def Ragent.start(occ_def)
+      @@occ_default = occ_def # This should not change during agent execution
+      @@logger.add('console')
+      3.times do |count| # In case of unexpected exceptions
+        begin
+          @@occ_reintroduction_wait_time = nil
+          @@is_busy = false # If agent is started from scratch assume previous one is gone
+          @@in_next_job = false
+          @@logger.info "====================================================================================="
+          mach_port = ENV['HOSTNAME'] + ':' + $oats['execution']['occ']['port'].to_s
+          @@logger.info "Started OATS Server execution-#{count} on #{mach_port} at #{Time.now} "
+          EventMachine::run do
+            EventMachine::start_server @@occ_default['agent_host'], @@occ_default['agent_port'].to_i, Ragent
+            EventMachine.next_tick do
+              Ragent.server_logger nil,'Initiating contact with OCC '
+              Ragent.start_next_job unless Ragent.is_busy
+            end
+          end
+          break # Shutdown requested
+        rescue Exception => exc
+          @@logger.error exc
+        end
+      end
+    end
+
+    #  def Ragent.force_close_connection
+    #  end
+    def Ragent.job_count=(val)
+      @@job_count = val
+    end
+    def Ragent.job_count
+      @@job_count
+    end
+
+    def Ragent.snapshot_oats_info(oats_info)
+      @@oats_info_snapshot = oats_info
+    end
+
+    # Generates summary data into the input oats_info
+    def regen_results_summary!(oats_info)
+      return Report.results(oats_info['test_files'],true)
+    rescue
+      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
+      false
+    end
+
+    # Results_status: Early, Partial, Current, Archived, Missing, Error
+    def get_oats_info
+      if @request[:jobid] == Ragent.is_busy # working on it now
+        if @request[:jobid] == @@oats_info_snapshot['jobid'] # first test started processing
+          if regen_results_summary!(@@oats_info_snapshot) # summary succeeded
+            oats_info = Marshal.load(Marshal.dump(@@oats_info_snapshot))
+            oats_info['results_status'] = 'Partial'
+          else
+            server_logger "[ERROR] Can not regen_results_summary from the snapshot"
+            oats_info = {'results_status' => 'Error'}
+          end
+        elsif @@oats_info_snapshot['jobid']
+          msg = "ERROR: Unexpected condition. Request jobid: #{@request[:jobid]} does not match stored job id: #{@@oats_info_snapshot['jobid']}"
+          server_logger msg
+          oats_info = { 'jobid' => @request[:jobid], 'results_status' => 'Error', 'error_message' => msg }
+        else
+          oats_info = Marshal.load(Marshal.dump(Oats.context))
+          oats_info['results_status'] = 'Early'
+          oats_info['jobid'] = Ragent.is_busy
+        end
+      else # Search for request on disk in archive or results
+        res_dir = File.join(Oats.result_archive_dir, @request[:jobid].to_s)
+        results_file = File.join( res_dir,'results.dump')
+        if File.readable?(results_file) # Archived ones should have summary
+          oats_info = Report.oats_info_retrieve(results_file)
+          oats_info['results_status'] = 'Archived'
+        else # May have to regenerate the summary, in case test had died
+          results_file = File.join( $oats['execution']['dir_results'], 'results.dump')
+          if File.readable?(results_file)
+            oats_info = Report.oats_info_retrieve(results_file)
+            if regen_results_summary!(oats_info) and @request[:jobid] == oats_info['jobid']
+              oats_info['results_status'] = 'Current'
+            else
+              oats_info = {} unless oats_info.instance_of?(Hash)
+              oats_info['debug_message'] = "request_jobid: #{@request[:jobid]}, current oats_info jobid: #{oats_info['jobid']}"
+              oats_info['results_status'] = 'Missing'
+            end
+          else
+            oats_info = { 'results_status' => 'Missing' ,
+              'debug_message' => "No readable: #{results_file}" }
+          end
+        end
+      end
+      # Convert object to hash
+      oats_info['test_files'] = oats_info['test_files'].testlist_hash if oats_info['test_files']
+      return oats_info
+    rescue
+      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
+    end
+
+    def receive_object(request)
+      @request = request
+      password = @request.delete(:password)
+      server_logger "Received " + @request.inspect
+      @request[:password] = password
+      response = {}
+      case @request[:command]
+
+      when 'status'
+        EventMachine.next_tick { run_next_job } unless Ragent.is_busy
+
+      when 'start'
+        if Ragent.is_busy
+          server_logger "Not getting next job again because Ragent.is_busy: #{Ragent.is_busy}"
+        else
+          EventMachine.next_tick { run_next_job }
+        end
+
+      when 'results'
+        begin
+          response[:oats_info] = get_oats_info
+        rescue
+          server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
+        end
+
+      when 'run' # only called from oats client, not from OCC
+        EventMachine.defer( proc {
+            Driver.start(@request[:jobid], @request[:args])
+          } ) unless Ragent.is_busy
+
+      when 'stop' # any further test execution for this jobid
+        Oats.context['stop_oats'] = @request[:id] if @request[:stop_jobs].include?(Oats.context['jobid'])
+
+      when 'shutdown'
+      else
+        response[:unknown_command] = true
+        server_logger "Unknown command #{@request[:command]}"
+      end
+      response[:is_busy] = Ragent.is_busy
+      stop_oats = Oats.context && Oats.context['stop_oats']
+      response[:is_signal_oats_to_stop] = stop_oats if stop_oats
+      server_logger "Sending " + response.inspect
+      response[:password] = password
+      send_object(response)
+      close_connection_after_writing
+    rescue
+      server_logger $!.inspect + "\n" + $!.backtrace.join("\n  ")
+    end
+
+    def unbind
+      if @request[:command] == 'shutdown'
+        server_logger "Shutting down the server."
+        EventMachine::stop_event_loop
+      end
+    end
+
+    def run_next_job(prev_jobid = nil)
+      return unless @request[:occ_host] # Bad input or invoked via client, not occ
+      occ = @@occ_default.clone
+      occ['server_host'] = @request[:occ_host]
+      occ['server_port'] = @request[:occ_port]
+      Ragent.start_next_job(occ, self, prev_jobid)
+    end
+
+    def self.start_next_job(occ = @@occ_default, ra = nil, prev_jobid = nil)
+      if Ragent.in_next_job or Ragent.is_busy
+        msg = if Ragent.in_next_job
+          if Ragent.in_next_job  == nil.object_id
+            "already getting the initial job."
+          else
+            "already getting job for #{Ragent.in_next_job}]"
+          end
+        else
+          "became busy with #{Ragent.is_busy}"
+        end
+        Ragent.server_logger ra, "Not requesting new job since #{msg}"
+        return false
+      end
+      Ragent.in_next_job = ra.object_id
+      # Double check that this agent has the busy lock
+      if not Ragent.in_next_job or Ragent.in_next_job != ra.object_id
+        Ragent.server_logger(ra, "Not requesting new job since " +
+            "now another Ragent #{ra.object_id} is requesting next job besides current #{Ragent.in_next_job}")
+        return false
+      end
+      query = {
+        'nickname' => occ['agent_nickname'],
+        'machine' => occ['agent_host'],
+        'port' => occ['agent_port'] }
+      query['jobid'] = prev_jobid if prev_jobid
+      query['repo'] = ENV['OATS_CODE_VERSION'].to_s if ENV['OATS_CODE_VERSION'] and ENV['OATS_CODE_VERSION'] != ''
+      query['logfile'] = File.basename(ENV['OATS_AGENT_LOGFILE']||'agent.log')
+      Ragent.server_logger ra, "Getting next OCC job: " + query.inspect
+      query['password='] = ra.request[:password] if ra and ra.request[:password]
+      # Default inactivity_timeout of 10 is not enough when OCC is restarting too
+      # many agents. Agent gives up in 10secs but OCC hands over the job in 20secs.
+      # As a result OCC thinks job is received but agent has never seen the job.
+      connection_options = { :connect_timeout => 60,:inactivity_timeout => 60}
+      http_req = EventMachine::HttpRequest.new('http://' + occ['server_host'] + ":#{occ['server_port']}",connection_options)
+      http = http_req.get :path => '/jobs/nxt', :query => query
+      http.errback  { self.no_response(occ,ra, prev_jobid) }
+      http.callback do
+        status = http.response_header.status
+        if status == 200
+          data =http.response
+          nxt_job = JSON.parse(data) if data
+          if nxt_job['jid']
+            Ragent.is_busy = nxt_job['jid']
+            Ragent.in_next_job = false
+            if ra
+              ra.jid = nxt_job['jid']
+              ra.occ_reintroduction_wait_time = nil # Reset wait time to default if heard from OCC
+            end
+            Ragent.server_logger ra, "Job-#{Ragent.job_count} #{nxt_job.inspect}"
+            EventMachine.defer do
+              begin
+                opts= {'execution:environments' => [nxt_job['env']],
+                  'execution:test_files' => [nxt_job['list']] }
+                opts['_:options'] = nxt_job['options'].split(',') if nxt_job['options'] and nxt_job['options'] != ''
+                Ragent.snapshot_oats_info({})
+                Driver.start(nxt_job['jid'],opts)
+              ensure
+                Ragent.is_busy = false
+              end
+              Ragent.job_count += 1
+              if ra
+                ra.run_next_job(nxt_job['jid'] )
+              else
+                Ragent.start_next_job(occ,ra,nxt_job['jid'])
+              end
+            end
+          else
+            Ragent.in_next_job = false
+            Ragent.server_logger ra, "No more pending jobs at OCC. Pausing processing.\n"
+            Ragent.job_count = 1
+            Ragent.server_logger ra, "***********************************************************\n"
+          end
+        else
+          self.no_response(occ,ra, prev_jobid)
+        end
+      end
+    rescue RuntimeError  => e.message
+      Ragent.in_next_job = false
+      if e.message == 'eventmachine not initialized: evma_connect_to_server'
+        Ragent.server_logger ra, "Shutting down..."
+      else
+        Ragent.server_logger ra, $!.inspect + "\n" + $!.backtrace.join("\n  ")
+      end
+    end
+
+    def self.no_response(occv,ra, prev_jobid)
+      Ragent.in_next_job = false
+      Ragent.server_logger ra, "OCC did not respond."
+      wait = ra ? ra.occ_reintroduction_wait_time : @@occ_reintroduction_wait_time
+      wait ||= $oats['execution']['occ']['timeout_waiting_for_occ']
+      # Keep retrying to introduce, doubling the intervals
+      self.server_logger ra, "Will retry in #{wait} seconds."
+      EM.add_timer(wait) do
+        Ragent.start_next_job(occv,ra, prev_jobid) unless Ragent.is_busy # by now
+      end
+      wait *= (1.5 + rand(101)/100.0)
+      wait = wait.round
+      if ra
+        ra.occ_reintroduction_wait_time = wait
+      else
+        @@occ_reintroduction_wait_time = wait
+      end
+    end
+
+    def server_logger(arg)
+      Ragent.server_logger self, arg
+    end
+
+    def Ragent.server_logger(ra, arg)
+      if ra
+        req = ra.request
+        jid = ra.jid
+        rt = ":R#{(req and req[:id]) ? req[:id] : ra.object_id}"
+        rt += "#{" J:#{jid}" if jid }"
+      end
+      @@logger.info "[RS#{rt}] #{arg}"
+    rescue
+      @@logger.error $!.inspect + "\n" + $!.backtrace.join("\n  ")
+    end
+
+  end
+end

data/lib/oats/rclient.rb

@@ -0,0 +1,42 @@
+module Oats
+
+  class Rclient < EventMachine::Connection
+    attr_reader :response
+    include EM::P::ObjectProtocol
+    #  def serializer
+    #    YAML
+    #  end
+    #
+    def initialize(host, request)
+      @host = host
+      @request = request
+    end
+
+    def receive_object(response)
+      @response = response
+      password = response.delete(:password)
+      length = 500
+      resp = response.inspect
+      resp = resp[0..length] + ' ..... ' + resp[-length..-1] if resp.size > 2*length
+      client_logger "Received " + resp + " from"
+      response[:password] = password
+      client_logger "Command was not recognized" if response[:unknown_command]
+    end
+
+    def client_logger(arg)
+      $log.info arg + " #{@request[:id]}@#{@host} at " + Time.now.strftime("%y-%m-%d %H:%M:%S")
+    end
+
+    def post_init
+      password = @request.delete(:password)
+      client_logger "Sending " + @request.inspect + " to"
+      @request[:password] = password
+      send_object(@request)
+    end
+    def unbind
+      client_logger "Did not hear from " unless @response
+      EventMachine::stop_event_loop
+    end
+  end
+
+end