Class: ButlerMainframe::HostBase

Inherits:
Object
  • Object
show all
Defined in:
lib/mainframe/host_base.rb

Overview

This is the host class base that contains high level logic It uses sub method that have to be defined in the specific sub class

Direct Known Subclasses

Host

Constant Summary collapse

MAX_TERMINAL_COLUMNS = 
80
MAX_TERMINAL_ROWS = 
24
WAIT_AFTER_START_SESSION =

SECONDS

3

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ HostBase

Returns a new instance of HostBase.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/mainframe/host_base.rb', line 13

def initialize options={}
  options = {
      :session_tag      => ButlerMainframe.configuration.session_tag,
      :wait             => 0.01,  #wait screen in seconds
      :wait_debug       => 2,     #wait time for debug purpose
      :debug            => false,
      :browser_path     => ButlerMainframe.configuration.browser_path,
      :session_url      => ButlerMainframe.configuration.session_url,
      :session_path     => ButlerMainframe.configuration.session_path,
      :timeout          => ButlerMainframe.configuration.timeout,
      :close_session    => :evaluate
                          #:evaluate    if the session is found will not be closed
                          #:never       never close the session
                          #:always      the session is always closed
  }.merge(options)

  @debug            = options[:debug]
  @wait             = options[:wait]
  @wait_debug       = options[:wait_debug]
  @session_tag      = options[:session_tag]
  @close_session    = options[:close_session]
  @timeout          = options[:timeout]
  @action           = {}
  @pid              = nil

  create_object options
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object (private)

If is called a not existing method there is the chance that an optional module may not have been added

Raises:

  • (NoMethodError) 


291
292
293
 
# File 'lib/mainframe/host_base.rb', line 291

def method_missing method_name, *args
  raise NoMethodError, "Method #{method_name} not found! Please check you have included any optional modules"
end

Instance Attribute Details

#action ⇒ Object (readonly)

Returns the value of attribute action.



6
7
8
 
# File 'lib/mainframe/host_base.rb', line 6

def action
  @action
end

#debug ⇒ Object

Returns the value of attribute debug.



7
8
9
 
# File 'lib/mainframe/host_base.rb', line 7

def debug
  @debug
end

#wait ⇒ Object (readonly)

Returns the value of attribute wait.



6
7
8
 
# File 'lib/mainframe/host_base.rb', line 6

def wait
  @wait
end

Instance Method Details

#close_session ⇒ Object

Ends the connection and closes the session



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/mainframe/host_base.rb', line 42

def close_session
  puts "Closing session with criterion \"#{@close_session}\"" if @debug
  case @close_session
    when :always
      sub_close_session
      puts "Session closed" if @debug
      wait_session 0.1
    when :evaluate
      if @pid
        sub_close_session
        puts "Session closed because started by this process with id #{@pid}" if @debug
        wait_session 0.1
      else
        puts "Session not closed because it was already existing" if @debug
      end
  end
end

#exec_command(cmd) ⇒ Object

Execute keyboard command like PF1 or PA2 or ENTER …



66
67
68
69
70
 
# File 'lib/mainframe/host_base.rb', line 66

def exec_command cmd
  puts "Command: #{cmd}" if @debug
  sub_exec_command cmd
  wait_session
end

#get_cursor_axes ⇒ Object

Return the coordinates of the cursor



139
140
141
 
# File 'lib/mainframe/host_base.rb', line 139

def get_cursor_axes
  sub_get_cursor_axes
end

#scan(options = {}) ⇒ Object

It reads one line or an area on the screen according to parameters supplied



73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/mainframe/host_base.rb', line 73

def scan options={}
  options = {
      :y => nil, :x => nil, :len => nil,
      :y1 => nil, :x1 => nil, :y2 => nil, :x2 => nil,
  }.merge(options)
  if options[:len]
    scan_row options[:y], options[:x], options[:len]
  else
    scan_area options[:y1], options[:x1], options[:y2], options[:x2]
  end
end

#scan_page ⇒ Object

Scans and returns the text of the entire page



86
87
88
 
# File 'lib/mainframe/host_base.rb', line 86

def scan_page
  scan_area 1, 1, MAX_TERMINAL_ROWS, MAX_TERMINAL_COLUMNS
end

#set_cursor_axes(y, x, options = {}) ⇒ Object

Move the cursor at given coordinates



144
145
146
 
# File 'lib/mainframe/host_base.rb', line 144

def set_cursor_axes y, x, options={}
  sub_set_cursor_axes y, x, options
end

#wait_session(wait = nil) ⇒ Object

Sleep time between operations



61
62
63
 
# File 'lib/mainframe/host_base.rb', line 61

def wait_session wait=nil
  sleep(wait || (@debug ? @wait_debug : @wait))
end

#write(text, options = {}) ⇒ Object

Write text on screen at the coordinates Based on the parameters provided it writes a line or an area Options:

:hook                       => nil,
:y                          => nil, #row
:x                          => nil, #column
:check                      => true,
:raise_error_on_check       => true,
:sensible_data              => nil,
:clean_first_chars          => nil, # clean x chars before writing a value
:erase_field_first          => nil  # erase first until end of field



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/mainframe/host_base.rb', line 101

def write text, options={}
  options = {
      :hook                       => nil,
      :y                          => nil, #row
      :x                          => nil, #column
      :check                      => true,
      :raise_error_on_check       => true,
      :sensible_data              => nil,
      :clean_first_chars          => nil, # clean x chars before writing a value
      :erase_field_first          => nil  # erase first until end of field
  }.merge(options)

  y           = options[:y]
  x           = options[:x]
  y         ||= get_cursor_axes[0]
  x         ||= get_cursor_axes[1]

  hooked_rows = 2
  raise "Missing coordinates! y(row)=#{y} x(column)=#{x} " unless x && y
  raise "Sorry, cannot write null values" unless text

  bol_written = false
  if options[:hook]
    (y-hooked_rows..y+hooked_rows).each do |row_number|
      if /#{options[:hook]}/ === scan_row(row_number, 1, MAX_TERMINAL_COLUMNS)
        puts "Change y from #{y} to #{row_number} cause hook to:#{options[:hook]}" if row_number != y && @debug
        bol_written = write_text_on_map text, row_number, x, options
        break
      end
    end
  else
    #If no control is required or was not found the label reference
    bol_written = write_text_on_map(text, y, x, options) unless bol_written
  end
  bol_written
end