require 'net/ssh'

Then /^I can ssh to "([^\"]*)" on port (\d+) with the following credentials:$/ do |host,port, table|
  @auth_methods ||= %w(publickey password)
  
  credentials = table.hashes
  credentials.each do |creds|
    lambda {
	    Net::SSH.start(host, creds["username"], :port => port, :password => creds["password"], :auth_methods => @auth_methods)
    }.should_not raise_error
  end
end


Then /^I can ssh to the following hosts on port (\d+) with these credentials:$/ do |port,table|
  @keys ||= []
  @auth_methods ||= %w(password)
  session_details = table.hashes

  session_details.each do |session|
    # initialize a list of keys and auth methods for just this session, as 
    # session can have session-specific keys mixed with global keys
    session_keys = Array.new(@keys)
    session_auth_methods = Array.new(@auth_methods) 

    # you can pass in a keyfile in the session details, so we need to 
    if session["keyfile"]
      session_keys << session["keyfile"]
      session_auth_methods << "publickey"
    end
    
    lambda {
	    Net::SSH.start(session["hostname"], session["username"], :port => port,
	                                                             :password => session["password"], 
                                                               :auth_methods => session_auth_methods,
                                                               :keys => session_keys)
    }.should_not raise_error(Net::SSH::AuthenticationFailed)
  end
end


When /^I ssh to "([^\"]*)" on port (\d+) with the following credentials:$/ do |hostname, port, table|
  @keys = []
  @auth_methods ||= %w(password)
  session = table.hashes.first
  session_keys = Array.new(@keys)
  session_auth_methods = Array.new(@auth_methods) 
  if session["keyfile"]
    session_keys << session["keyfile"]
    session_auth_methods << "publickey"
  end
  session_port=port 
  

  lambda {
    @connection = Net::SSH.start(hostname, session["username"], :password => session["password"], 
                                                                :auth_methods => session_auth_methods,
                                                                :port => session_port,
                                                                :keys => session_keys)
#                                                                :keys => session_keys,:verbose => :debug)
  }.should_not raise_error
end

#
When /^I run "([^\"]*)"$/ do |command| 
  @stdout=nil
  @stderr=nil
  @exitcode=-9999
  channel = @connection.open_channel do |ch|
	  ch.request_pty do |ch, success|
      if success
#		    puts "pty successfully obtained"
		  else
#		    puts "could not obtain pty"
		  end
	  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|
        if @stdout.nil?
          @stdout=data
        else  
          @stdout+=data
        end
      end

      # "on_extended_data" is called when the process writes something to stderr
      ch.on_extended_data do |c, type, data|
          if @stderr.nil?
            @stderr=data
          else  
            @stderr+=data
          end
      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
        @exitcode=exit_code
      end
      
      channel.on_request("exit-signal") do |ch, data|
        #puts "SIGNAL: #{data.read_long}"
      end

      ch.on_close {
        #puts "done!"
      }
    end
  end
  channel.wait
  if !@stdout.nil?
    if @output.nil?
      @output=""
    end
    @output=@output+@stdout
  end
  if !@stderr.nil?

    if @output.nil?
      @output=""
    end
    @output=@output+@stderr
  end

end

Then /^It should execute without errors$/ do |exitcode|
  @exitcode.should = 0
end

Then /^it should have exitcode (\d+)$/ do |exitcode|
  @exitcode.to_i.should == exitcode.to_i
end


Then /^I should see "([^\"]*)" on stdout$/ do |string|
  @stdout.should =~ /#{string}/
end

Then /^there should be no output on stderr$/ do
  @stderr.should == nil
end

Then /^there should be no output on stdout$/ do
  @stdout.should == nil
end


Then /^I should see "([^\"]*)" on stderr$/ do |string|
  @stderr.should =~ /#{string}/
end

######################################################################################################################################
## Cucumber-nagios original starts here
Given /^I have no public keys set$/ do
  @auth_methods = %w(password)
end

Then /^I can ssh to "([^\"]*)" with the following credentials:$/ do |host, table|
  @auth_methods ||= %w(publickey password)
  
  credentials = table.hashes
  credentials.each do |creds|
    lambda {
	    Net::SSH.start(host, creds["username"], :password => creds["password"], :auth_methods => @auth_methods)
    }.should_not raise_error
  end
end

Then /^I can ssh to the following hosts with these credentials:$/ do |table|
  @keys ||= []
  @auth_methods ||= %w(password)
  session_details = table.hashes

  session_details.each do |session|
    # initialize a list of keys and auth methods for just this session, as 
    # session can have session-specific keys mixed with global keys
    session_keys = Array.new(@keys)
    session_auth_methods = Array.new(@auth_methods) 

    # you can pass in a keyfile in the session details, so we need to 
    if session["keyfile"]
      session_keys << session["keyfile"]
      session_auth_methods << "publickey"
    end
    
    lambda {
	    Net::SSH.start(session["hostname"], session["username"], :password => session["password"], 
                                                               :auth_methods => session_auth_methods,
                                                               :keys => session_keys)
    }.should_not raise_error
  end
end

Given /^I have the following public keys:$/ do |table|
  @keys = []
  public_key_paths = table.hashes

  public_key_paths.each do |key|
    File.exist?(key["keyfile"]).should be_true
    @keys << key["keyfile"]
  end

  @auth_methods ||= %w(password)
  @auth_methods << "publickey"
end

When /^I ssh to "([^\"]*)" with the following credentials:$/ do |hostname, table|
  @keys = []
  @auth_methods ||= %w(password)
  session = table.hashes.first
  session_keys = Array.new(@keys)
  session_auth_methods = Array.new(@auth_methods) 
  if session["keyfile"]
    session_keys << session["keyfile"]
    session_auth_methods << "publickey"
  end

  lambda {
    @connection = Net::SSH.start(hostname, session["username"], :password => session["password"], 
                                                                :auth_methods => session_auth_methods,
                                                                :keys => session_keys)
  }.should_not raise_error
end

Then /^I should see "([^\"]*)" in the output$/ do |string|
  @output.should =~ /#{string}/
end